There’s lots to say about cake, here just a quick note, for myself or for anyone in case you are running into the same problem.

Situation: you are using the Ajax helper, which contains a method isAjax() – returns true if the request was an Ajax request.

Typically, you use this method inside a view, to conditionally render content for regular/ajax views. Example:

...
if (! $ajax->isAjax()) {
// render general page stuff
}
// render stuff for both regular- and ajax view
...


My problem was that the isAjax() call never returned true, regardless of ajax/regular request method.

The solution appears to be really simple: you should include the 'RequestHandler' component in your controller class. This one took me way too long to figure out!


public $components = array (
'Auth',
'Cookie',
'RequestHandler'
);


Update my situation was even worse than described above; I use a redirect between controllers within an Ajax call, something which is officially supported by Cake 1.2. This worked just fine in Safari, but not in Firefox (and Opera) – these browsers would not load the Ajax view but rather the complete page, almost crashing the server by consuming huge amounts of memory.

Read on…

Lots and lots of troubleshooting did not help, after which I tried my last bet: update Cake to the current development build.
And that appeared to be the solution! Not only solves this the Ajax detection problem, the whole application seems to be much more efficient too.

The Cake SVN repository is organised somewhat unconventional. A quick recipe for getting the last development revision…

The repository is rooted at https://svn.cakephp.org/repo/.

There are the common subdirectories, amongst others:

• branches
• tags
• trunk

In this case, Trunk contains the last released (beta) versions, while branches contain, well, the trunk repository.
So in order to get the current HEAD release, you have to get the source from /branches/1.2.x.x.

Command line:

svn co https://svn.cakephp.org/repo/branches/1.2.x.x/

I’m working with revision 6461, highly recommended!

Tweet This Delicious Reddit This Post Stumble This Post

1. More Mashups: Using Greasemonkey to Weave New Features into Web Sites
2. Building a Greasemonkey Mashup Tutorial
3. Greasemonkey in the Enterprise: When is GM the Right Tool for IT?
4. Beware of Greasemonkey’s Inverted Security Model
5. Solving the Greasemonkey Script Versioning Problem

The first two articles are a very nice and moderate technical introduction to Greasemonkey. The next installment starts to position GM as a valuable corporate intranet addition, with a checklist to find out if it is the right tool for your situation. The last two articles focus on the important security- and deployment issues, focused on the corporate situation again.I’m really curious whether corporate IT department heads will really be convinced by these articles. The checklist (part 3) lists a number of very frequent corporate / intranet annoyances where GM will help and the author’s background (BEA) is very trustworthy, so I give it a good chance.Definitely worth a read, even if you’re not a corporate IT head!

Tweet This Delicious Reddit This Post Stumble This Post

His reasons not to do so are:

• Most CSS naked sites are generated from templates, so what is the individual blog author’s effort?
• The target audience is missed, it is merely preaching for already converted style purists
• The target market is missed: those really crappy intranets within big corporations

My reasons for still participating with my (slightly modified) WordPress blog…

You definitely have a point with the generated code/templates based blogs. Last year, I adapted my site layout to have the content first and navigation and boilerplate stuff to the bottom in the HTML stream. That was fun and even sped up the apparent rendering of my site with CSS enabled. So I did learn something usefull in the process as well.

That site structure is generated from templates as well, but all handcrafted XML/XSLT stuff (in Firefox, select the alternate style CSS Naked Day to see how it works).

Now I’m using WordPress and, indeed, just installed a plugin for ‘Naked Day. OK, so my contribution was to adapt that plugin for WP 2.1.x.

About the corporate software/intranet stuff: you are completely right. But here I feel that bottom-up advocacy does work in the longer term. In my former (large) organisation, I got quite a few corporate J2EE developers interested in standards compliant CSS web techniques, especially after they had a very bad time trying to meet the requirements from our User Interaction specialists. The advance of Ajax does the rest.

In just another 5 years or so, even those big vendors might have “got it” (and then go wondering what that “semanic web” stuff is all about )

Tweet This Delicious Reddit This Post Stumble This Post

Now, a lot of relevant things have been said around the ‘net (see my prevous post). And, there have been some in-depth reviews of the model of Freebase, related to the Semantic Web: Denny Vrandecic, Danny Ayers.

I will not repeat these comments here, rathter give my first impressions as a curious explorer.

First of all, the Freebase website is very heavy on Ajax, which seems to be almost essential for the functionality provided.
As a novice user, you are launched at the “User Profile” page. While starting to fill out some profile fields, you are immediately confronted with the Metaweb Object Model (login needed).

The Freebase Object Model

The model roughly consists of:

• Domain (the top level ontology, e.g. ‘music‘ or ‘business‘)
• Type (a class within a domain, e.g. music/artist)
• Topic (an individual object, let’s say Frank Zappa as musical artist)
• Property (attributes, e.g. ‘name’ or ‘date of birth’, or a relation with another Topic)

So when you start editing your User Profile, you are actually filling out a template of a User Type. Within this type, the attribute “Me as a Freebase Topic” links to an object of class (Type) ‘people/person‘. The distinction is somewhat like the difference between a real world (verifyable) person, and personas this person might use. From the Freebase documentation:

A person topic is distinct from a user in Metaweb. Users have profiles that can only be edited by the users themselves. A person topic can be edited by anyone and is intended as a factual representation of details about a person.

A couple of primitive Types exist (e.g. type/intor type/text), but in most cases more complex types are used for attributes. So Place of Birth is not just a text sctring, but an object of type ‘location/location‘. This ensures that all occurrences of ‘Baltimore, Maryland‘ refer to the same object.

Following the link to this location, you can zoom in further and find that the object is not only of type ‘location/location‘, but also ‘location/citytown‘ and ‘location/us_county‘.

Queries and results

Freebase is called a database for a reason: you can run queries against it and get results back. Now being heavily rooted in the semantic web terminology, you might expect to use SPARQL as a query language, and results back in some RDF representation. But this is not the case.

Both queries and results are expressed in plain JSON, which is becoming the data transport protocol of choice for most Ajax projects and frameworks.

A trivial example of using this Metabase Query Language.

Query:

{
  "qname": {
    "query":{
      "type" : "/music/artist",
      "name" : "Frank Zappa",
      "album" : {
        "name" : "Hot Rats",
        "track" : []
      }
    }
  }
}

Response:

 ({
  "status": "200 OK",
  "qname": {
    "status": "/mql/status/ok",
    "result": {
      "album": {
        "track": [
          "Peaches en Regalia",
          "Willie the Pimp",
          "Son of Mr. Green Genes",
          "Little Umbrellas",
          "The Gumbo Variations",
          "It Must Be a Camel"
        ],
        "name": "Hot Rats"
      },
      "type": "/music/artist",
      "name": "Frank Zappa"
    }
  }
})

This makes building a front end web application for Freebase almost trivial!

API: full CRUD interface

The API doesn’t stop at letting you query the existing Freebase data. You can Create, Read, Update or Delete objects all through the JSON API, as long as you have sufficient permissions to do so.

This means that you can soon start using Freebase as an alternative for you own, isolated database for your web applications. And so make the world a better place by sharing all data you and your users enter through your application. And, of course, benefit from the data which is already in Freebase. The only consideration is the license: all data in Freebase is available under the Creative Commons Attribution license (CC-BY).

All this functionality can be vulnerable to spamming or vandalizing, just like Wikipedia content. The Freebase folks have clearly thought about this problem. They provide a granular permission mechanism, as well as community vigilance tools like “report as spam” links and “revert” operations.

Conclusion

So far, my first impressions are overwhelming in a good sense.
The Freebase already contains quite a few models as well as a lot of content, mostly imported from compatible sources like Wikipedia.

The future of Freebase will depend on the adoptation by developers and users equally. Will we be able to get the Answer to Life, the Universe and Everything soon, or will it become the next Dmoz project?

Tweet This Delicious Reddit This Post Stumble This Post

In just a few words, Reflection means that Objects are open to (self-) inspection, so that you can interrogate an object for all kinds of properties at runtime.

Now if you have classes with getter (and setter) methods, there are some very elegant techniques with reflection. Normally, these getters and setters are used to give access to the data contained in the object. Good Object Oriented practice makes use of these Data Objects to build a clean boundary between the data and implementation details.

So, let’s assume that you have painfully crafted a class definition with accessors and you want to serialize the contained data as JSON over the wire. Of course, you can write a getJsonString() method for every class. But Reflection gives you a much nicer option.

An example of serialization into JSON, entirely based on Reflection:

function toDataObj($myObj) {
    $ref = new ReflectionClass($myObj);
    $data = array();
    foreach (array_values($ref->getMethods()) as $method) {
        if ((0 === strpos($method->name, "get"))
                && $method->isPublic()) {
            $name = substr($method->name, 3);
            $name[0] = strtolower($name[0]);
            $value = $method->invoke($myObj);
            if ("object" === gettype($value)) {
                $value = toDataObj($value);
            }
            $data[$name] = $value;
        }
    }
    return $data;
}

print json_encode(toDataObj($myObj));

What is going on here?
First, I have a data object, referenced by $myObj, with a couple of getter methods.
Then, a new reflection object is instantiated for myObj. This reflection object contains a whole lot of reflection methods, of which getMethods() is used here.
In the foreach loop, a every method of the myObj is inspected in turn. Here we look for methods whose name start with “get” (the name property). Then we normalize the name (getMyVariable => myVariable) and call the original method of myObj through invoke($myObj).
If the returned value is an object itself, the function toDataObj is recursively called with this object.
Then, the name, value pair is stored in a hash list (called Array in PHP).
Finally, this hash is serialized into JSON.

The cool thing is that this function is really universal.
It will take just any object with getter methods and due-fully serialize the data, which then can be turned into a JSON stream, ready to consume in your Ajax applications.

Reflection class
The Reflection class and all of its subclasses are available in PHP 5.1.x, no need to include anything.

PHP JSON
If you’re running PHP 5.1.x, you most likely have json_encode() available, but you may need to enable the php_json extension in php.ini.
Otherwise download, build and install the extension and add the line extension=php_json.so (*nix) or extension=php_json.dll (Win32) in php.ini and you should be up and running.

Tweet This Delicious Reddit This Post Stumble This Post

EXIF Thumbnail Fetcher is a Greasemonkey user script, which lets you retrieve the embedded thumbnail of a digital camera image over the ‘net, without downloading more than strictly needed.

See my previous post for some more details. And, please test it and let me know your experiences!

Tweet This Delicious Reddit This Post Stumble This Post

The idea is simple: if you have your original digicam photos online, just bulk downloaded from the camera, you only have very non-descriptive names for reference. Was that one interesting image called IMG_1234.jpg, or was that the blurry one and are you looking for IMG_2345.jpg? Your only option seems to download the whole blob, easily several MBytes per image for contemporary multi Mega Pixel camera.

Now there is hope for a smarter solution.
Most digicam images have embedded meta data in the Exif format, often including a nice little thumbnail.

Wouldn’t it be nice to retrieve this embedded data over the network to preview a photo by thumbnail?

I haven been working on this problem and have a proof of concept ready, coded as Greasemonkey user script for Firefox (1.5 and 2.0).

From a very high level the working principle is:

For each image,
    •    Open a binary clean XHR connection
    •    Retrieve the first one K of image data (using HTTP 1.1 Byte Ranges)
    •    Find embedded Exif data; if found
    •    Retrieve the rest of the Exif header
    •    Extract the embedded thumbnail
    •    Append a new image, set source to thumbnail data (hex-encoded as data:xxx/yyy URL).

All in all, the savings in bandwidth are at least some 90%, as the embedded Exif data with thumbnail seldom exceed 60k, and even significantly less for older camera models.

Now this works, but it is still very rough around the edges.
Firefox gets completely locked up during data retrieval and parsing, I suspect that this is due to the CPU intensive exif parsing and synchronous XHR data retrieval.

I’ll be polishing and optimizing the script, planning a next post in a few days….

Tweet This Delicious Reddit This Post Stumble This Post

Last Monday, Marcus Granado posted “Downloading Binary Streams with Javascript XMLHttpRequest“, where he demonstrates that it is possible to get a binary clean stream through XMLHtttpRequest.
It boils down to using the right Charset in with the proprietary overrideMimeType() function. Read his post to see how.

In one word: Wow! This opens up a whole lot of new applications, for instance with Greasemonkey scripts.

I’m glad I have been proven wrong!

Update: this does not work for me as is…

What happens is that all bytes above 127 (decimal) are returned as a really big value. The solution, however, appears to be very simple:

var filestream = load_url(url);
var c = filestream.charCodeAt(x);
if (c > 255) c -= 63232;

Apparently, the extra high value is not caused by extra bytes being gobbled up, but constructed on the fly. Luckily this is done in such a deterministic way.

I’m working with javascript in a UTF-8 page context and, although I have experimented with some other character sets for the page, this made no difference. I’m using Firefox 1.5.0.6, Mac OSX right now.

I’m really interested in other users’ experiences. Please share them via the feedback form!

Tweet This Delicious Reddit This Post Stumble This Post

There is a solution, though: just listen for DOM events which modify the page’s content. Keep up with the DOM changes so to say!

Background

In the days before Flickr was acquired by Yahoo, I made a Greasemonkey user script: Flickr – Link Original Image that inserts direct links to the original uploaded photos on top of thumbnails. This worked fine, by parsing the DOM just after page load and looking for every occurrence of photo thumbnails.

Now, after the recent relaunch of Flickr with dynamic Ajax loading, this script fails for those dynamically inserted thumbnails. Simply because they do not exist in the DOM when the page completes loading.

Solution

DOM level 2 specifies a couple of Mutation events. Now I register an event handler for the relevant events and take action whenever an image gets inserted, removed or moved around.

Code example

// Ajax: new image
document.addEventListener("DOMNodeInserted",
	function(evt) {
		ImgLinks.insertLinks(evt.target);
	}, true);
// Ajax: remove an image
document.addEventListener("DOMNodeRemoved",
	function(evt) {
		var list = evt.target.getElementsByTagName("img");
		for (var i = 0; i < list.length; i++) {
			ImgLinks.remove(list[i]);
		}
	}, true);
// DOM manipulation, which can cause reflow
document.addEventListener("DOMAttrModified",
	function(evt) {
		ImgLinks.reshuffleSoon();
	}, true);
// catch window resize events
window.addEventListener("resize",
	function() { ImgLinks.reshuffle(); }, true);

In order to watch an Ajax page, you just have to keep up with the change, and go with the flow!

Tweet This Delicious Reddit This Post Stumble This Post

But what exactly means “problematic” in this context?

I gave it a try with Firefox and found out that every byte above 0x7f is translated into 0xfd. In other words: Plain old ASCII is left alone, everything above it results in a fixed value of 0xfd. Guess this has to do with the stream being interpreted as UTF-8 text…

A hex dump of a binary range [00 .. ff], retrieved through XMLHttpRequest:

joe$ od -t x1 -v xhrsweep.bin
0000000    00  01  02  03  04  05  06  07  08  09  0a  0b  0c  0d  0e  0f
0000020    10  11  12  13  14  15  16  17  18  19  1a  1b  1c  1d  1e  1f
0000040    20  21  22  23  24  25  26  27  28  29  2a  2b  2c  2d  2e  2f
0000060    30  31  32  33  34  35  36  37  38  39  3a  3b  3c  3d  3e  3f
0000100    40  41  42  43  44  45  46  47  48  49  4a  4b  4c  4d  4e  4f
0000120    50  51  52  53  54  55  56  57  58  59  5a  5b  5c  5d  5e  5f
0000140    60  61  62  63  64  65  66  67  68  69  6a  6b  6c  6d  6e  6f
0000160    70  71  72  73  74  75  76  77  78  79  7a  7b  7c  7d  7e  7f
0000200    fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd
0000220    fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd
0000240    fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd
0000260    fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd
0000300    fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd
0000320    fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd
0000340    fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd
0000360    fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd  fd
0000400

Tweet This Delicious Reddit This Post Stumble This Post