CR should feel very familiar to Rails developers. Its interface is akin to ActiveResource and it borrows heavily from the (very good) ObjectiveResource library for the iPhone.

All basic CRUD operations are supported, and you can perform advanced finds with arbitrary parameters. A brief example of fetching a record, modifying it, and saving it:

var post = [Post find:@"42"];
[post setTitle:@"Why X is Better than Y"];
[post save];

Check out the README on the project’s page on GitHub for more details and usage examples.

Live Demo

I also created a demo application which is a simplified clone of OS X’s Address Book. The demo is live on Heroku. Check it out. The source for the demo is also on GitHub.

If you’re a Rails developer waiting for a good opportunity to try out Cappuccino, there’s no better time than now.

If you’re a Cappuccino developer looking for an easy-to-use, powerful back-end for your applications, Rails might be the answer for you.

CR is a young project, but it drives one of my client applications that is production-ready (albeit not deployed), so I believe it is ready for prime time. Please try it and let me know how it goes.

Fork, report issues, et cetera.

Here is a very basic way to test if your app is posting event notifications as you expect it to. First, create an Observer class inside a test helper file, which will be included into your tests:

// this is TestHelper.j
@import <Foundation/CPObject.j>
 
@implementation Observer : CPObject
{
    CPArray postedNotifications;
}
 
- (id)init
{
    if (self = [super init])
    {
        postedNotifications   = [CPArray array];
    }
    return self;
}
 
- (void)startObserving:(CPString)aNotificationName
{
    [[CPNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(notificationPosted:)
                                                 name:aNotificationName
                                               object:nil];
}
 
- (void)notificationPosted:(id)sender
{
    [postedNotifications addObject:[sender name]];
}
 
- (BOOL)didObserve:(CPString)aNotificationName
{
    return [postedNotifications containsObject:aNotificationName];
}
 
@end

This class can be configured to register for certain notifications via -startObserving and when they are posted, it stores them in an array (postedNotifications). You can then ask it at any time if a notification has been observed using the -didObserve method and it will respond with YES or NO.

So, to use this in your tests, do something like this:

// This is MyTest.j
@import "TestHelper.j"
 
@implementation MyTest : OJTestCase
 
- (void)setUp
{
    observer = [[Observer alloc] init];
}
 
- (void)testMyMethodDidPostNotification
{
    [observer startObserving:@"MyMethodDidFinishExecution"];
    // do stuff that you would expect to get the notification posted
    [self assertTrue:[observer didObserve:@"MyMethodDidFinishExecution"];
}
 
@end

You could get more fancy with this (like allowing object observing and not just name observing), but the concept doesn’t change. Hope this helps anybody thinking about how to test their Capp apps!

In it I build a simplified version of the payment calculator from chapter 2 of Cocoa Design Patterns.

Topics covered include creating a Cib-based project, laying out an interface and binding outlets/actions to working code.

Hope it helps!

280 Atlas Introductory Screencast from Jerod Santo on Vimeo.

Related Posts:

• Learning Cappuccino: Resource List
• CappuccinoFlow

Along the way I’ve compiled a list of valuable resources. I believe many others will be taking this same journey in the coming days (especially once Atlas drops), so I’m sharing my findings for the benefit of all.

Laying Foundation

JavaScript: The Good Parts – the book to read on JavaScript

Cocoa Programming for Mac OS X – focus on the “how” of Cocoa

Cocoa Design Patterns – focus on the “why” of Cocoa

Introduction to Cappuccino & Objective-J – you’ve probably already read this

Learning Objective-J – this too, but if you haven’t you absolutely should

Objective-C for Rubyists – great ($9) screencast if you’re coming from a Ruby background like me

Tutorials & Walk-Thrus

Scrapbook Tutorial – first “real” tutorial on cappuccino.org

Nice-Panorama Tutorials – great breadth of content here

CappuccinoCasts – Thomas does a great job with these. Watch ‘em all

Reference Material

Cappuccino Online Documentation – Unfortunately these are often outdated

Compiling from source – includes how to compile a local version of the documentation

Apple’s Cocoa Documentation – Often fills the voids in Capp’s documentation for certain topics

Cocoa Browser Air – A great tool for browsing Apple’s documentation on a Mac

Staying Informed

Official Cappuccino Blog – duh

280 North’s blog – because they’re driving this train

This Week in Edge Cappuccino – summaries of recent changes & additions

CappuccinoFlow – a link blog with content provided by the community

GitHub repository – if you’re hardcore you can watch every commit to the project

Getting Help

Google Group – good archives to search here as well

IRC Channel – direct IRC link

Google Wave – this is pretty new & I haven’t personally used it much

That’s what I’ve found & used so far. I plan on updating this page when I come across new helpful resources so come back from time to time and consider subscribing to my blog as well.

Also, let me know in the comments of Cappuccino resources you’ve found valuable and I’ll add them to the list. Cheers!

I just launched CappuccinoFlow: a community driven link blog for the Cappuccino framework. If you’re at all interested in this amazing new technology out of 280north, make sure to subscribe to the RSS feed, follow along on Twitter, and post cool Cappuccino-related links to the flow!

In Detail:

It has been a little quiet around these parts lately. I blame Cappuccino.

For the uninitiated, Cappuccino is a framework for writing web applications (for example). It is built on Objective-J, which is an Objective-C-esque superset of JavaScript. It is completely rad. Also, it’s all client-side so I still get to use Rails on the back-end. I believe the apt word is: woot.

I wanted a link blog to support the small, but growing, Cappuccino community. I’m a big fan of RubyFlow so I contacted its creator, Peter Cooper, and asked him if I could set one up for Cappuccino. He was gracious enough to say yes, and he had conveniently open-sourced an old version of his site awhile back. I forked it on GitHub and the result is CappuccinoFlow.

I’ll probably have to modify my blog’s headline soon, because once I become proficient in Objective-J & Cappuccino you’ll probably see some posts about it.