Liverail - Home

RailsDAV now up for Rails 2.0.2

2008-02-23T11:01:00Z

Hi all,

The RailsDAV plugin for integrating WebDAV controllers into your Rails application is now compatible with Rails 2.0.2. I’m doing a complete re-write to make RailsDAV easier to use and work with merb as well, but it’s slow going.

You can install RailsDAV with


ruby script/plugin install http://svn.liverail.net/svn/plugins/railsdav

Adobe Media Player

2007-10-03T11:00:00Z

It’s starting to look at lot like Christmas… well for Flash developers anyhow

That comes from Daniel Todd and I think he’s referring to the amount of new goodies Adobe released in the last couple of days. We had the AIR Beta 2 Flex 3 Beta 2 Thermo and Adobe Media Player. Thankfully the new AIR beta fixes my favorite ~~making AIR useless~~ bug synchronous database access

But its Adobe Media Player I’m loving at the moment. It’s an AIR app and it needs the new beta runtime and for those who know nothing about it, basically it’s a cross between iTunes and Joost but for Flash video. With a modified RSS feed video suppliers can create a channel of Flash video for people to watch, favorite and share. It downloads the video so you can watch it offline as well.

So far, so iTunes. But a channel feed can also include branding elements to give every channel a different look. But not too special right. It’s the future of AMP that’s exciting, the ability to embed advertising, pre-rollers, post-rollers, interactive elements. The Buy that shirt the guy in the video has element which makes AMP attractive for content producers and distributers.

But a more interesting future for AMP is allowing companies to white-label it, skinning and modifying the player to create their own iTunes/BBC iPlayer (without the DRM and with the Mac!). A great idea, I’m just surprised Adobe is there first. Normally I would expect to see this kind of thing coming out of a company like Brightcove

RailsConf Europe - Wednesday Sessions - 3

2007-09-19T14:23:00Z

This is my last session of the day as i’ll have to run about by 5 and dive in a taxi to catch my flight.

Extending Rails to Use the Presenter Pattern

The Extending Rails to Use the Presenter Pattern could be re-titled talking Ruby On Rails beyond MVC by Jay Fields of ThoughtWorks.

He lost me quickly in ThoughtWorks-Speak, referencing everything in the ideas of Enterprise patterns. It’s Martin Fowler world. It’s tough to talk to people who may not be fully versed in your lingo and get the subtle references.

I’m gathering some ideas that Presenters are a way to make testing controllers easier and view testing isn’t really worth it (which I’ll agree with).

I’ll suggest checking out “Jay’s blog’:http://blog.jayfields.com/ if you are interested in these things as I didn’t get much out of this at all, Jay doesn’t even like the pattern. It was only about 25 minutes as well…. The person behind me just said “I’m feeling a bit swissed…..” and next to me “Possibly one of the most over-hyped talks here”

RailsConf Europe - Wednesday Sessions - 2

2007-09-19T13:24:00Z

First of all, some of the presentation downloads for RailsConf Europe have started appearing on the O’Reilly site here, so please run along and grab them. Nothing to see here.

Well ok, i’ll continue live-blogging from the afternoon sessions but I have a plane to catch soon :-)

Development Case Study: MindMeister

I’ve chosen the lest technical session because sometime the anecdote, the story, is more useful than the code. Development Case Study: MindMeister is the story off the online mind mapping tool “The google docs of mind mapping” apparently.

MindMeister It’s all AJAX (and a lot of it), tough call I think the interface could be way better in Flex and you have offline Mind-mapping possibilities with AIR.

They started with prototyping, then some design concepts , which all looked quite good if you ask me.

The name was the hardest thing to fine.

I hear that.. It is very hard to find a name. I agree you shouldn’t be obsessed with finding a free .com domain name, 37signals never did.

Private betas are good, 2 launches making it exclusive with lots of feedback. Starting with just friends but allowing invites to others. No longer than 2 months with an upgrade offer at the end.

They got lots of competitors and clones after launching which I think is a common problem, just make sure you are the brightest and the best. MindMeister have some good user stats, better traffic than their competitors (according to Alexa) but less features than the competitors. Usability is what makes them better. Every euro spent on design is worth it..

Recommendations

Get a great designer on board
Target non-technical users
Watch every Apple demo

Marketing

Write to bloggers
Post site to app portals
Create an API
Write regular newsletter & blog posts
“Add to del.icio.us / digg” button
Spend time (and money) on SEO
Be generous with Premium accounts
Don’t comment spam
Don’t pay for placements and ads

Don’t start charging before its really stable
Carefully select premium features
Think of students et al

Technical Issues

Everybody has them
It pays to be honest
Explain what happened
Announce maintenance windows

It seems MindMeister are going offline with Google Gears which is the right move, maybe AJAX was a good choice after all. Use a canvas library which turns to VRML on IE.. And Wirecard

I’ve got to day playing with it now MindMeister is pretty good, its slick works well and I can see how it would be both useful and easy with is important in brainstorming tools. Bravo guys!

Outsourcing to Open Source

Another non-technical session Outsourcing to Open Source from Tobias Luetke at “Shopify’:http://www.shopify.com/. I chose this because i’m a real fan of Shopify, JapedPixel and because it’s more relevant to my business than the others. But I wish I could also have gone to Exploring Very Rapid Web Development Techniques with Hobo by Tom Locke, but those the breaks..

Tobias is talking about Liquid which for those that don’t know is a safe templating method for Rails which you can give to customers to make their own designs/themes without them breaking your app. And he wrote it on the plain to RailsConf 2005!! Not only is it safe but only exposes what you want to expose ie.


class Product << ActiveRecord::Base
liquid_methods :title, :price, :description

If you don’t know about liquid, go look it up. If you ever developing a SaaS with needs safe themes for users, its a great fit. Tobias is also talking about Vision which is a downloadable theme engine which works offline. Using this tool the launched a competition for themes for shopify with an iPod nano, the people who entered then now do full time Shopify themeing and earn more money from it than JadedPixel!!

Vision works by donwloading a Mock version of Shopify with no backend but the objects returned have real like data. Like a massive test case your users can download and theme.

JapedPixel also issued the open source AcitveMerchant as a library for payment processing gateways. It is really useful contribution to Rails. It supports 40+ gateways. Often they are commission by shopify customers who pay a ruby developer to contribute a specific merchant to ActiveMerchant which then automatically appears in Shopify. This is a great example of crowd-sourcing helping the community which then helps your product. It’s like work for free….

Crowdsourcing

Crowdsourcing is a neologism for the act of taking a job traditionally performed by an employee or contractor, and outsourcing it to an undefined, generally large group of people, in the form of an open call. For example, the public may be invited to develop a new technology, carry out a design task, refine an algorithm or help analyze large amounts of data.

Examples of crowdsourcing are threadless.com, freebase, Mechanical Turk, PeertoPatent, OrganizedWisdom. Tobias simple example of CrowdSourcing is giving your users the ability to create a new translation of text in checkout and feed that back to the system. They get credit for the translation and shopify track the progress of translation. This allows them to email authors when they add a new string that needs translation.

A really good talk from Tobias but he could have gone into the theme of crowd-sourcing more than than shopifies use of it, then given the examples. Just a structural thing.

For those interested. Shopify use Solr and love it. From being a public facing Rails application they get some really random requests such as a whole Shakespeare text in a param!. The run 25,000 public facing with different URLs, so they get a lot of web-spiders on the servers. They use memcache generating a unique key for every possible input for a page, check memcache to see if it has a version. If memcache doesn’t have it they gzip it and stick it in memcache. They use version numbers of each object and the version number is part of the key, instead of expiring they just have to lookup a new key and get a cachemiss so generate it. No cache invalidation.

RailsConf Europe - Wednesday Sessions - 1

2007-09-19T09:38:00Z

Trying to make better choices today which shouldn’t be too hard. So I decided on following up my Flex on Rails background (which I havn’t be exploring recently), but since I was the first tutorial on integrating Flex and Rails, I thought i’d check on it’s progress.

Building Rich Internet Applications with Flex and Ruby on Rails

This session was given by Simeon Bateman, who although not Adobe is certainly a Flex expert and has real world in-anger experience of Flex and Rails.

Unfortunately Simeon spent far too much time on Flash background and had some problems with the Internet before getting to the good stuff. But did manage to quick demonstrations of

HTTPService using XML REST responses from Rails
AMF using WebORB
AMF using RubyAMF

To his credit the last 15 mins was some of the best and explained the advantages of AMF over HTTPService with great examples. Simeon reckons that RubyAMF is the way to go in the future as WebORB has not been updated in a year, other people I know concur with that.

The other question for people interested in Flash/Flex is:

What is Thermo?

Creating Hybrid Web and Desktop Applications with Rails and Slingshot

A session by Joyent on Slingshot. This is something i’ve had an interest in for a while, in the realms of the online/offline applications. In theory Slingshot offers downloadable Rails applications that run on the desktop but syncs with an online web-application.

It will do syncronisations, and you can extend the sync-hooks and will need to implement aggregate_data for your models to get the sync works. But it won’t do conflict resolutions, but it does handle auto-increment ids and foreign-key problems on the syncronisation side which is a pretty tough problem. It can also sync files as well as data between online and offline. You must have timestamps on your model to sync models which make sense.

I will do some drag and drop stuff but only on Mac OS X. This is a real problem, and certainly AIR could overtake easily in this area. I would like to see how I could get RailsDAV working with Slingshot on this.

Your code will be visible in the download, it is after all Ruby. So it better be open-source application on a behind firewall deployment. I don’t think this is this biggest problem as people won’t be able to copy it without the web-application component.

They downloads can be big. 20MB is the initial hit and applications can be as big as 100MB.

Overall it seems better on Mac OSX than Windows. It has DMG packaging, XCode customisation and changing Info.plist while the Windows deployment looks a lot harder.

In practice, its not complete. Here is a list of things it won’t do (Yet)

sync conflict resolution
encrypt your code
domain specific online/offline issues
package you application automatically
update itself + your Rails app code
native menus

But this is still one of the most interesting and innovative things being talked about at RailsConf Europe so was certainly worth intending. The presentation was well done and paced well, including presentation then questions then demo which is a lot to fill 45 minutes. Showing you don’t have to aim your presentation at the lowest common demoninator.

I’m wondering if you could just use the sync_controller parts of slingshot and write an AIR end…. Evil but useful.

Great demo..

RailsConf Europe - Wednesday Keynotes

2007-09-19T07:49:00Z

Partly due to having to check out my hotel, partly due to my hangover and partly due to not being bothered I missed today’s pre-roller advert by ThoughtWorks to today’s keynotes.

But i’m here now for the session on Best Practices. A bit late. Siting at the back nursing my headache.

The Best Practices session is very codey but still entertaining so far covering test-first, associations, method naming and chaining. Expressive Interfaces they call them, readability and undestanding. Now moving on to with_scope and the dangers of using a before_filter with a scoped command, hence reducing all queries to a limited scope. For instance only finding posts for the current user. Instead use associations:


current_user.posts.find(params[id])

But it has uses. You can use method_messaging with a with_scope and create a dynamic has_many association through a proxy. Similarly very cool but I can see that being mis-used also. I think using method_missing should be a last resort, documented heavily and only used if it significantly improves readability or time. Not really as a best practice.

The use of conditions and commands in Ruby can be confusing as there is many ways of doing it. The question, which can be understood quickest?


command if conditional?
....
if conditional?
  command
end
...
conditional? and command
...
conditional? && command
...

All of the above do the same. For me number 2 is clearest but involves more typing, but I hate mixing up commands with conditionals in an expression, and the speakers agree.

RailsConf Europe - Tuesday Keynotes

2007-09-18T15:28:00Z

Tuesday is ending now with some final keynotes

Beyond Startups: Rails Demand in the Global 2000 Jonathan Siegel, President, ELC Technology
The Rest of REST Roy T. Fielding, Chief Scientist, Day Software
Rails and the Next Generation Web Craig R. McClanahan, Senior Software Engineer, Sun Microsystems, Inc.

Basically sandwiching in Roy Fielding, a uber-guru of the web between some Diamond sponsors seems like a commercialization thing. A theme of the conference maybe.

Beyond Startups: Rails Demand in the Global 2000

Thanks to Jonathan Siegel we heard the obvious, that yes some Global 2000 companies are starting to use Rails. Big shock. Shame the man can’t present at all. Little note, if your sponsorship money buys you a presentation, learn how to present an engaging talk.

The Rest of REST

An intellectual and precise talk by Roy Fielding, was interesting and historically educating but academic for most people there. Still I find the elements of architectural style and forming lasting styles of architecture is really interesting from a consulting point of view. The architectural style a way of deducing principles of technology removed from any of the problems of actual languages and products.

Rails and the Next Generation Web

Craig McClanahan is a great speaker and someone we are interested to hear from. This should be the principle of buying your speaking slot, put up something interesting with an interesting topic, not just a marketing speech.

Craig talks about his love of Ruby and Rails even after being a Java-guy for so many years. A shift for Sun? Rich Internet Applications and Horizontal scaling, gone is Moore’s Law. Well Craig says that Java web frameworks pace of innovation is slowing, and the Java community know they need to look to the future. Could the Rails community go snow-blind also? Forget to look to the future..

Mentions three plugins. act_as_cached, act_as_state_machine, will_paginate… get it wrong as they only extend ActiveRecord. While acts_as_autenticator, paginator gets it right as they don’t care about the implementation.

make_resourceful plugin is a good example of separating API from implementation where you could plugin ActiveResource or ActiveRecord.

Unfortunately Craig only has 50 minutes which is no time at all. I would love to hear a proper 2 hr talk from him as it seems he has some great stuff to say.

RailsConf Europe - Choosing sessions is so hard...

2007-09-18T14:57:00Z

Tuesday at RailsConf and choosing sessions is damn hard. Am I missing out on something really great going on in other room? Could the other guys be as boring as this speaker? With nothing more than a title and a synopsis we select from our buffet.

My bad decisions so far:

Chose Making Rails More (Artificially) Intelligent. Should have chosen Deployment and Continuous Integration from the Trenches. Although non of the first sessions were apparently great
Chose Meta-Magic in Rails: Become a Master Magician. Should have chosen Meta-Magic in Rails: Become a Master Magician. Very funny, entertaining, informative and very very popular.
Chose Really Scaling Rails. Should have chosen Utilizing Amazon S3 and EC2 in Rails
Chose Tabnav: Do We Really Need a Plugin for Tabbed Navigation?. Should have chosen Tabnav: Do We Really Need a Plugin for Tabbed Navigation?. Although I hear Rubinius, Improving The Rails Ecosystem was really good, the Tabnav talk was entertaining and something I may use soon.

Making Rails More (Artificially) Intelligent

The speakers were in Spanish and their English was difficult to understand especially in a presentation context, but well done for giving it a go guys. Basically the talk introduced Bayesian graphs and probability tables, Bayesian classifiers and genetic algorithms and some Ruby libraries for using them. Unfortunately they didn’t make the Rails context at all. I think a talk on using these kind of algorithmic tools would be a winner with the right presentation context. But hard when it’s not your first language.

I learnt something and it’s worth checking the libraries if you ever feel you’ll need to solve an AI problem.

Meta-Magic in Rails: Become a Master Magician

Very entertaining and very popular, if the conference room had rafters people would be hanging from them. The room was packed. I would hate to go up against Dr Nic, the other rooms must have been empty.

I quit coding because I thought I hated it, turned out I just hated Java.

Dr Nic not only talked about fun little things with method_missing, const_missing and using the meta abilities of Ruby he used them as a weapon against other languages

Java is like… Keith Richards. not so cute anymore, can tell you stories about himself, can’t change his behavior

Great talk but Dr Nic was keen to point out that that in some cases the meta-magic is.

not useful but it is funny..

Really Scaling Rails

Was by a Twitter guy on scaling and had some bits of useful information but really didn’t engage. The really useful elements were a few tips such as how to encode the page peformance into every the response of every page. A shame.

Tabnav: Do We Really Need a Plugin for Tabbed Navigation?

A lovely talk by Italian speaker Paolo Dona who was engaging and funny. I expected the room to be near empty, after all who needs to hear about tabbed navigation. Instead Paolo packed the small room he was given, obviously they knew more than me.

Paolo’s main thing was that sure Ruby on Rails has meant he has had to write less code but he still spends the same amount of time writing HTML/CSS. In fact relatively he was spending much more time on HTML/CSS than coding.

where is DHH? I want to kill him. He has turned me into a designer.

So Paolo has widgets

  
ruby script/plugin install svn://svn.seesaw.it/widgets/trunk

Widgets for tabs, navigation, showhide, tablizer, tooltips, nubbins. To create user interface design patterns with less effort. It’s a fine idea and i’ll look to use them soon.

Not a bad spread for the food either…..

RailsConf Europe - Dave Thomas Keynote

2007-09-18T10:10:00Z

Last night Dave Thomas kicked off RailsConf Europe with something different. Rather than evangelize Rails or talk up the lastest/next big thing, Dave set the tone for the conference by stripping back it to the core philosophy’s of software development and created a grand analogy.

Rails and Art

Dave’s well spoken, in a mid-atlantic accent, and funny keynote concentrated on the definition of software development as art or engineering. By making multiple analogies to software development to famous works of art and the methods of artists of history, Dave was trying to create a philosophy behind not just good software but truely great, beautiful software. He looked at four main things.

Starting

Just as the artist is faced with a blank canvas, the developer is faced with a blank IDE. But an artist doesn’t jump right in and start to create the masterpiece. Instead the use sketching and work in other mediums to deduce how a masterpiece will evolve. Consequently the developer should work in other mediums, or index cards or lego. They could use prototyping of small complex areas, exploratory testing to validate understanding and creating a “tracer bullet”, a complete end-to-end system but without any details, later they can fill in the details or just start over.

be prepared to throw 10 away, because the 11th will be sweet.

Stopping

In a grand mosiac such as the sistine chapel, its hard to be close to the detail when the work is so large. So Dave talks about about how to chapel is broken into panels, all unique “loosely coupled” but come together to tell a long story. Hence developers can set boundaries not just in function (modularisation) but in time then honouring those boundaries. Short distinct length development times and if your feature is only half finished at the end. Stop and be prepared to throw it out and do it again in the next iteration.

Satisfy the customer

Pictures versus portraits. An artist painting a portrait tries to look inside someone and find a way to express it, even if its abstract its still a representation. The developer needs to find a way to satisfy the underlying requirement.

Be in the habit of not listening to the client.

But to do so a developer needs to look beyond the surface, be appropriate, work with client and get to know them. Dave used two great anecdotes, the NASA space pen (the real story) and the driving license camera as two conflicting stories. Where some clients don’t realize they have the need for a technology solution but some clients don’t need high technology, listen to what they really need.

Why

There is art in engineering and engineering in art.

Be an artist. Create something great. Create something beautiful.

Sign your work. No more anonymous applications

My review

I really liked Dave Thomas’s keynote, he is a fine speaker, smart and inspirational. Talking to a few people afterwards there was a little “Yeah but that’s what we are like…” but for two things..

Not all developers are the artists they think they are.
The majority of development teams don’t know this at all, they are stuck in the production mentatility of ‘lines of code produced per hour’ and ‘man-days effort’

I think Dave’s keynote would have gone down best with the non-technicals, the managers, the CTO’s, the executives. Maybe then they can treat the developers a bit better than code generation machines and like real artisans.

Stuart Eccles

RailsConf Europe - In Berlin

2007-09-18T08:46:00Z

I arrived in Berlin yesterday and the sun was shining, that makes a change from London but today its raining, so exactly like London.

There is a large assembly of Railers, official figures have 39% Germans, 19% Brits, 11% Americans and the rest. Dave Thomas did his keynote last night (more to come) and DHH is just finishing his this morning.

I have some starter pictures for you:

LiveRail off to Berlin RailsConf Europe

2007-09-13T08:38:00Z

Just to confirm that I will be off to Berlin next week and will be hanging around at RailsConf Europe on the 18-19th. If you want to talk RailsDAV, Flex with Rails, Facebook or the state of the media industry in London, ask around for me.

I’ll be blogging from the event also, like many many others ;-)

Great Plugin for Facebook Apps

2007-07-27T10:04:00Z

If you’ve been working through the Facebook/Rails tutorials you might find this plugin useful.

Facebook on Rails is a sexy plugin for developing Facebook apps

It adds some useful functions to Rails for creating a Facebook application.

acts_as_fb_user


class CreateUsers < ActiveRecord::Migration
  def self.up
    create_table :users do |t|
      t.column :uid, :integer, :null => false
      t.column :session_key, :string
    end

    add_index :users, :uid, :unique
  end

  def self.down
    drop_table :users
  end
end

class User < ActiveRecord::Base
  acts_as_fb_user

  def self.import(fbsession)
    user = self.find_or_initialize_by_uid(fbsession.session_user_id)

    # Assumes session_key never expires
    if fbsession.session_key != user.session_key
      user.session_key = fbsession.session_key
      user.save!
    end

    return user
  end
end

you can now do things with the user object such as get a user’s friends


>> u = User.find(1)
=> #<User:...>
>> u.friends
=> [1, 2, 3]

FBMLController

You can create FBMLControllers such as


class ApplicationController < Facebook::FBMLController
  before_filter :require_facebook_install
  before_filter :import_user

  private
  def import_user
    @user = User.import(fbsession)
  end
end

Although I still feel this doesnt need to be inherited and such just extend the ApplicationController.

API Calls.

Are now easier, no need to parse the Hpricot XML. And also you can use the fbsession in the Model objects (where it belongs)


class MyController < Facebook::FBMLController
  def friends
    @me         = Facebook::Users.get_info(fbsession.session_user_id, ['first_name', 'last_name'])
    @first_name = @me.first_name
    @last_name  = @me.last_name
    @friends    = Facebook::Friends.get
  end
end

Notifications like ActionMailer


class StampNotificationPublisher < Facebook::NotificationPublisher
  def stamp(friends)
    @to_ids = friends.map(&:uid)
    @text   = "just stamped on you" 
  end
end

I advise you check it out if you plan to write any applications for Facebook.

Continuing Facebook Applications with Ruby On Rails

2007-07-16T16:47:00Z

This is the continuing tutorial from the last post Tutorial on developing a Facebook platform application with Ruby On Rails where we can take the social recipe application and add some more Facebook features including posting to the feed, profile boxes, profile actions, the Facebook Query Language and sending out invitations to a user’s friends to come join in the cooking fun (oh boy). So lets get down to it, I’m presuming you have been through the first tutorial and have a working Facebook application. Even if you havn’t got it deployed today’s examples will work with an IFRAME application also.

Before we get into it Evan Weaver has posted two really useful things for Facebook and Ruby on Rails. First a way to output the Facebook exceptions nicely when viewing in Facebook and Second how to develop an application locally while tunneling from a server Facebook can see.

Sending events to the feed.

One of the features that makes Facebook so great is the powerful News Feed’s and mini-feed which keeps you updated on what’s going on with your friend’s lifes and in-touch with your application content. The Facebook API allows you to do two things with the feed. You can publish a News Feed story to just the user logged in with

    
fbsession.feed_publishStoryToUser(:title => "", :body => "", :image_1 => "")

or publish a Mini-Feed story to the user and a News Feed story to their friends with

    
fbsession.feed_publishActionOfUser(:title => "", :body => "", :image_1 => "")

In both cases you can publish up to four images in the story with will be strung to a 75×75 square by Facebook and cached and served by them. Additionally the stories may not show up depending on the quality of the other competing stories in the feed! Applications are also limited to calling feed_publishStoryToUser once every 12 hours for each user and feed_publishActionOfUser to 10 times in 48 hours for each user.

Now to our application. We are going to notify the user and all their friends when they create a new recipe so all their friends can go check it out and cook it. So in recipes_controller and the create action.

    
if @recipe.save

  fbsession.feed_publishActionOfUser(:title => "<fb:name/> 
  has added a recipe for <a href=\"http://apps.facebook.com#{url_for(:controller => 'recipes', :action => 'show', :id => @recipe, :only_path => true)}\" >#{@recipe.title}</a>", 
   :body => "#{@recipe.summary}")

In this case we use a url_for to add the URL to an absolute path. This is necessary for Facebook as all links on the pages outside your application must be absolute. We also have used a little FBML to display the user’s name in the news feeds.

Now it would be great if we could use observations on ActiveRecord models to do this but the fbsession is available only in the controllers, a limit of rfacebook

Adding a profile box to a user’s profile page

The profile box is a little mini-view of your application which is on a user’s profile page The quirk behind profile boxes is the don’t send a request to your application to display the content. Instead you must set what content (in FBML) will appear in your application box for each user. This is a push method rather than a pull method. More information here.

So when do you actually set the profile box content. Well it depends what you are putting in the box, if you are just updating it with information about the users data then you may want to update that users profile box after a certain event. If you have information from a users friends data you may need to update a users profile box and update any of their friends after a certain event.

In our case the profile box is going to contain just a list of the recipes a user has added, but we are going to keep it keep generic. Try adding this to the ApplicationController

    
def update_profile(uid = fbsession.session_user_id)
  #find the user specific recipes
  recipes = Recipe.find_my_recipes(uid)

  #render a partial to a string
  profile_box = render_to_string(:partial => 'users/profile_fbml', :locals => { :uid => uid, :recipes => recipes })

  #send the profile FBML to Facebook through the API for this user
  fbsession.profile_setFBML({:markup => profile_box, :uid => uid})
end

We can then call update_profile from any controller to update a users profile, by default it will update the current user but we can override this to say update a friends profile.

For the partail we need to create app/views/users/_profile_fbml.rhtml

    
<fb:if-is-own-profile>
  <fb:subtitle>You have created <%=pluralize(recipes.size, 'recipe')%></fb:subtitle>
  <fb:else>
   <fb:subtitle>
    <fb:name uid="<%=uid%>"/> has created <%=pluralize(recipes.size, 'recipe')%>
   </fb:subtitle>
  </fb:else>
</fb:if-is-own-profile>
<%recipes.each do |recipe| %>
  <div>
    <h2><a href="http://apps.facebook.com<%= url_for :controller => 'recipes', :action => 'show', :id => recipe%>">
    <%=h(recipe.title)%></a></h2>
    <p><%=h recipe.summary %></p>
  </div>
<%end%>

<fb:if-is-app-user>
<fb:else><a href="http://www.facebook.com/add.php?api_key=28e9f67df073c92829aa003e6762e074">
    Add Social Recipe for yourself</a></fb:else>
</fb:if-is-app-user>

This FBML code works in two ways, first if the user is viewing there own profile it says You have created but if someone else if viewing their profile it says Stuart Eccles has created for instance. We then link to the recipes, note the use of absolute URLs, a must on the profile box. Finally if another user has not added the application we chuck in a sneaky plug to our application. Note the api_key you will want to move this to a constant.

Finally we need to call the update_user and we will do so after a create or delete action on a controller i.e.

    
def update
  @recipe = Recipe.find(params[:id])

  if @recipe.update_attributes(params[:recipe])
   flash[:notice] = 'Recipe was successfully updated.'

   update_profile
   redirect_to :action => 'show', :id => @recipe
  else
   render :action => "edit" 
  end
end

Adding a profile action to a user’s profile page

A profile action appears as a link just under a users picture on their profile. The profile action link should be set at the same time as the profile box so to add a link we just need to add a bit of FBML to the end of the _profile_fbml.rhtml

    
<fb:if-is-own-profile>
<fb:profile-action url="http://apps.facebook.com<%= url_for :controller => 'recipes', :action => 'my'%>">
View My Recipes (<%=recipes.size%>)
</fb:profile-action>
<fb:else>
<fb:profile-action url="http://apps.facebook.com<%= url_for :controller => 'recipes', :action => 'index'%>">
View <fb:pronoun uid="<%=uid%>" possessive="true" capitalize="true"/> Recipes (<%=recipes.size%>)
</fb:else>
</fb:profile-action>
</fb:if-is-own-profile>

Again it gets switched depending on if the user is viewing their profile or someone else. If it is someone else we use the fb:pronoun to output His or Her.

Adding an application invitation

Our application is so cool no your users are going to want to share it with their friends (well yours will be, this tutorial application lacks coolness). So lets allow users to invite their friends.

We only want people to be inviting their friends how havn’t already added the application, unfortunately we don’t have an API call for this. Fortunately there is a way around this but we have to use the Facebook Query Language which is just like a select SQL statement. We can select data from the user, friend, group, group_member, event, event_member, photo, album, photo_tag tables. We can then call the API through fql_query method on fbsession, this will return XML we can then parse. You can try out your FQL first at the test console.

We need to create an invites controller:

    
script/generate controller invites

    
class InvitesController < ApplicationController

  def select
    fql =  "SELECT uid, name FROM user WHERE uid IN" +
    "(SELECT uid2 FROM friend WHERE uid1 = #{@current_fb_user_id}) " +
    "AND has_added_app = 0" 
    xml_friends = fbsession.fql_query :query => fql
    @friends = Hash.new
    xml_friends.search("//user").map do|usrNode| 
      @friends[(usrNode/"uid").inner_html] = (usrNode/"name").inner_html
    end
    render_facebook
  end

end

In this code we select friends of the current user where the friends has_added_app = 0 so therefore are not using the application. We then parse their names and uids into a hash. Lets create two outputs for this list, a normal HTML one and an FBML one.

app/views/invites/select.rhtml

    
<% form_tag :action => 'send_invites' do -%>
<ul>
<% @friends.each do |uid,name|%>
     <li><input type="checkbox" name="friends[]" value="<%=uid%>"/> <%=name%></li>
<%end%>
</ul>

You can only invite a maximum of ten people at once.
<input type="submit" value="Invite"/>
<% end -%>

app/views/invites/select_fbml.rhtml

    
<% form_tag :action => 'send_invites' do -%>
<ul>
<% @friends.each do |uid,name|%>
     <li><input type="checkbox" name="friends[]" value="<%=uid%>"/><fb:profile-pic uid="<%= uid %>" size="thumb" /> <%=name%></li>
<%end%>
</ul>

You can only invite a maximum of ten people at once.
<input type="submit" value="Invite"/>
<% end -%>

The only difference is in the FBML version we have outputted a picture. You can style this in table or any way you want really but Facebook will only let you send 10 notifications at once and only 20 a day for each user. Now we need the send_invites action added to the controller

    
      def send_invites
        invite = render_to_string(:partial => 'invites/invite_fbml', :locals => { :inviter => @current_fb_user_id })

        friends = params[:friends]
        if friends.is_a? String
          invitees = friends
        else
          invitees = friends.values.join(",")
        end

        result_xml = fbsession.notifications_sendRequest(:to_ids => invitees, :type => 'Social Recipe', :content => invite, :invite => true, :image => "http://apps.facebook.com/socialrecipe/P1010825_tiny.jpg")

        response = CGI.unescapeHTML((result_xml/"notifications_sendrequest_response").inner_html)

        if response =~ /^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix
          #need to do a confirmation redirect
          if in_facebook_canvas?
            render :text => "<fb:redirect url=\"#{response}\"/>", :layout => false
          else
            redirect_to response
          end
        else
          flash[:notice] = 'Invites sent.'
          redirect_to :controller => 'recipes', :action => 'index'
        end
      end

Similar to the profile box we are using a partial with render_to_string to create the FBML to send in the notification. We pass in the inviter uid to use as a local in the partial. Note that the image parameter is required in the API call even if you don’t have an image to show! Once we have a response from the API call we will either be returned a URL to redirect the user to confirm the notification or it will return nothing at all. The redirect has to be handled in different way depending on if you are in the canvas, if you are you need to output the fb:redirect tag.

If it returns nothing if either means no confirmation is necessary and the notification was sent or there was an error….. hmmmm lets be optimistic and say it was sent shall we.

    
You have been invited to upload your recipes to Social Recipe! 
<fb:name uid="<%= inviter%>" firstnameonly="false" shownetwork="false"/> wants you to add Social Recipes so you can share recipes together
<fb:req-choice url="http://www.facebook.com/add.php?api_key=916c58dd4fba835cc43389a432fa98d0" label="Add" />
<fb:req-choice url="http://apps.facebook.com/socialrecipe" label="Go to Application" />

The fb:req-choice will give the user in the notification the options to add the application or go to it. If you now submit the form

Wrapup

So that’s all, there are a few more things to discover in the application interface but you should have all the basic elements to create some fun apps to share with your friends and their friends. There is certainly not enough error handling in here for a production application but i’ll leave that up to the reader.

Tutorial on developing a Facebook platform application with Ruby On Rails

2007-06-29T12:25:00Z

If you havn’t heard of Facebook. Where you been, living in a cave! Well you also probably know that in June 2007 Facebook opened a development platform for integrating new applications into Facebook, also codenamed F8. By the 24th June there were a 1,000 new applications available for the Facebook networkers to play with. According to both the online and traditional news media, Facebook have changed the game.

Well ZDNet are reporting that 1,000 developers a day are joining Facebook platform. That as it may, they are not all creating applications right away. The documentation is patchy, spread-out, difficult to understand and incomplete. It is a wonder so many applications are built because there is pain to go through to get there.

But this article is a complete tutorial for building a simple Facebook application in Ruby On Rails and should allow you to hit the ground running. We are going to create a recipes sharing application for Facebook from scratch.

UPDATE: The second part can be found here

First of all some useful links:

Facebook has provided many different integration points and different APIs to an application so it is worth reading Anatomy of a Facebook Application first which will explain the areas an application can affect for a user.

There are two different types of Facebook application

A desktop application
A website application

We are only going to be concerned with website applications for now. There is also 3 different ways an application can interact with Facebook.

As an external application but interacting with the remote API
Running in an IFRAME on the Facebook site
Running in a Facebook canvas and using Facebook Markup Language (FBML)

The application can use one or all of these techniques. We are going to try all three in this tutorial.

But first lets start by creating a Rails application with NO Facebook stuff and then we’ll look at FB-ing it. Originally I planned to do this completely RESTfully but it turns out it doesn’t work well with Facebook canvas, so it’s old-skool Rails i’m afraid.

Lets create the application:

    
rails socialrecipe

cd socialrecipe

And create some models. We are keeping this application very simple for demo purposes so just a recipe and a comment model needed. (you will need to concate these lines properly)

    
ruby script/generate model Recipe 
title:string summary:text ingredients:text instructions:text 
cooking_time:string created_at:datetime updated_at:datetime

ruby script/generate model Comment 
recipe_id:integer body:text created_at:datetime updated_at:datetime

Lets create our databases. I’m using MySQL

    
sudo mysqladmin create socialrecipe_development
sudo mysqladmin create socialrecipe_test

Lets changed to using database sessions. Now edit config/environment.rb change the Rails Initializer section and uncomment the following line

    
config.action_controller.session_store = :active_record_store

And add a line at the end of config/environment.rb

    
ActionController::AbstractRequest.relative_url_root = "/socialrecipe"

What this does is change the Rails application to run starting with a socialrecipe in the first part of the URL. We need this for later but you will need your own unique name (i’m using socialrecipe). So think of one and take note.

Now lets create our development database.

    
rake db:sessions:create

rake db:migrate

Now lets create our controllers

    
ruby script/generate controller recipes 
ruby script/generate controller comments

Excellent. Now lets change our model definitions so that Recipes can have many comments. Edit app/models/recipe.rb to

    
class Recipe < ActiveRecord::Base
    has_many :comments

    validates_presence_of :title, :summary, :ingredients, :instructions
end

And edit models/comment.rb to

    
class Comment < ActiveRecord::Base
    belongs_to :recipe

    validates_presence_of :body, :recipe_id

end

Now lets add the controller for the recipe. Edit app/controllers/recipes_controller.rb and change it to

    
class RecipesController < ApplicationController

  def index
    @recipes = Recipe.find(:all)
    @title = "All recipes" 
  end

  def show
    @recipe = Recipe.find(params[:id])
  end

  def new
    @recipe = Recipe.new
  end

  def edit
    @recipe = Recipe.find(params[:id])
  end

  def create
    @recipe = Recipe.new(params[:recipe])

    if @recipe.save
      flash[:notice] = 'Recipe was successfully created.'
      redirect_to :action => 'show', :id => @recipe
    else
      render :action => "new" 
    end

  end

  def update
    @recipe = Recipe.find(params[:id])

    if @recipe.update_attributes(params[:recipe])
      flash[:notice] = 'Recipe was successfully updated.'
      redirect_to :action => 'show', :id => @recipe
    else
      render :action => "edit" 
    end
  end

end

Edit app/controllers/comments_controller.rb and change it to

    
class CommentsController < ApplicationController

  def new
    @comment = Comment.new
    @comment.recipe_id = params[:recipe_id]
  end

  def create
    @comment = Comment.new(params[:comment])
    if @comment.save
      flash[:notice] = 'Comment was successfully created.'
      redirect_to :controller => 'recipes', :action => 'show', :id => @comment.recipe
    else
      render_action 'new' 
    end
  end
end

Pretty standard stuff so far creating simple controllers to create, read and update recipes and create comments. Lets setup the views

Add app/views/recipes/index.rhtml with

    
<h2><%= @title %></h2>

<%@recipes.each do |recipe|%>
<div>
<h3><%= link_to h(recipe.title), :controller => 'recipes', :action => 'show', :id => recipe%></h3>
<p><%=h recipe.summary %></p>
</div>
<%end%>

<br/>
<%= link_to 'New recipe', :controller => 'recipes', :action => 'new' %>

Add app/views/recipes/new.rhtml with

    
        <h1>New recipe</h1>

        <%= error_messages_for :recipe %>

        <% form_for(:recipe, :url => {:controller => 'recipes', :action => 'create'}) do |f| %>
          <dl>
              <dt><label for="recipe_title">Title:</label></dt>
            <dd><%= f.text_field :title %></dd>
            <dt><label for="recipe_summary">Summary:</label></dt>
            <dd><%= f.text_area :summary %></dd>
            <dt><label for="recipe_ingredients">Ingredients:</label></dt>
            <dd><%= f.text_area :ingredients %></dd>
            <dt><label for="recipe_instructions">Cooking Instructions:</label></dt>
            <dd><%= f.text_area :instructions %></dd>
            <dt><label for="recipe_cooking_time">Cooking Time:</label></dt>
            <dd><%= f.text_field :cooking_time %> mins</dd>
            <dt></dt>
            <dd><%= submit_tag "Create" %></dd>
          </dl>
        <% end %>

        <br/>
        <%= link_to 'Back', :controller => 'recipes' %>

The use of dl tags for forms is not a facebook thing. It’s just the way I rock it.

Add app/views/recipes/edit.rhtml with

    
<h1>Editing recipe</h1>

<%= error_messages_for :recipe %>

<% form_for(:recipe, 
      :url => {:controller =>'recipes', :action => 'update', :id => @recipe}) do |f| %>
<dl>
    <dt><label for="recipe_title">Title:</label></dt>
    <dd><%= f.text_field :title %></dd>
    <dt><label for="recipe_summary">Summary:</label></dt>
    <dd><%= f.text_area :summary %></dd>
    <dt><label for="recipe_ingredients">Ingredients:</label></dt>
    <dd><%= f.text_area :ingredients %></dd>
    <dt><label for="recipe_instructions">Cooking Instructions:</label></dt>
    <dd><%= f.text_area :instructions %></dd>
    <dt><label for="recipe_cooking_time">Cooking Time:</label></dt>
    <dd><%= f.text_field :cooking_time %> mins</dd>
    <dt></dt>
    <dd><%= submit_tag "Update" %></dd>
</dl>
<% end %>

<br/>
<%= link_to 'Show', :controller => 'recipes', :action => 'show', :id =>@recipe %> |
<%= link_to 'Back', :controller => 'recipes' %>

Add app/views/recipes/show.rhtml with

    
<h1><%=h @recipe.title %></h1>
<p><%=h @recipe.summary %></p>

<h2>Ingredients:</h2>
<p><%=h @recipe.ingredients %></p>

<h2>Instructions:</h2>
<p><%=h @recipe.instructions %></p>

<p><em>Cooking time is around <%=h @recipe.cooking_time %> mins</em></p>

<div id="comments">
    <h2>Displaying <%=pluralize(@recipe.comments.size, 'comment')%></h2>
    <%= link_to 'New comment', :controller => 'comments', :action => 'new', :recipe_id => @recipe %>
       <% @recipe.comments.each do |comment| %>
           <div>
                <p><%= comment.body %></p>    
                posted <%= time_ago_in_words(comment.created_at)  %> ago
            </div>
       <%end %>
</div>

<br/>
<%= link_to 'Edit', :controller => 'recipes', :action => 'edit', :id => @recipe %> |
<%= link_to 'Back', :controller => 'recipes' %>

Add app/views/comments/new.rhtml with

    
<h1>New comment</h1>

<%= error_messages_for :comment %>

<% form_for(:comment, :url => 
      {:controller => 'comments', :action => 'create'}) do |f| %>
<dl>
    <dt><label for="comment_body">Body Content:</label></dt>
    <dd><%= f.text_area :body %></dd>
    <dt></dt>
    <dd><%= submit_tag "Create" %></dd>
</dl>
    <%= f.hidden_field :recipe_id, :value => @comment.recipe_id %>
<% end %>

And lets create a layout at app/views/layouts/index.rhtml

    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
  <title>Recipes: <%= controller.action_name %></title>
</head>
<body>
<p style="color: green"><%= flash[:notice] %></p>

<%= yield  %>

</body>
</html>

and add this line to the app/controllers/application.rb

    
layout 'index'

change config/routes.rb to have a default route

    
map.connect '', :controller => "recipes"

and delete index.html from your public directory. That’s it. We now have a simple (and very ugly application). Fire it up with script/server and go to http://localhost:3000/socialrecipe

Lets facebook-it!! First of all we need to install the Ruby Gem RFacebook (this tutorial uses the version 0.6.2. This is a helper for interacting with the Facebook APIs. It will require you install Hpricot but make sure you pick the ruby version not the jruby one.

    
sudo gem install rfacebook -v 0.6.2

Now you’ll need to log on to facebook (what do you mean you’re not on facebook!) and add the Developer application. Once you have done that press the big “Set Up New Application” button.

Now fill in the following fields

Application Name: Social Recipes (You will need to change this as i have done social recipes) Check the box for Check here to indicate that you have read and agree to the terms of the Facebook Platform. Callback Url: http://localhost:3000/socialrecipe/ (The end of this is the same as your relative_url_root) Canvas Page URL: http://apps.facebook.com/ socialrecipe (The field of this is the same as your relative_url_root) Check Use iframe for now Can your application be added on Facebook? Yes Post-Add URL: http://apps.facebook.com/socialrecipe/ (The end of this is the same as your relative_url_root)

That is all hit save and you should have a page listing your application with an API Key and a Secret. Make a note of your applications API Key and Secret

Now lets edit our rails application. Add the following to your ApplicationController in app/controllers/application.rb

    
before_filter :require_facebook_login, :set_user
include RFacebook::RailsControllerExtensions

def facebook_api_key
  return "ADD YOUR API KEY HERE" 
end

def facebook_api_secret
  return "ADD YOUR SECRET HERE" 
end

def finish_facebook_login
  redirect_to :controller => "recipes" 
end

def set_user
  @current_fb_user_id = fbsession.session_user_id
end

and add the following to your config/environment.rb

    
require "facebook_rails_controller_extensions"

You’ll see you need to add your own key and own secret to this. The set_user filter is going to set a variable in the controller with the logged in facebook users id. We need this because we are going to store which users created which recipes and comments. To do this we need to add columns to our recipes and comments tables to store the id in. These must be BIGINT if you are using MySQL. Facebook has A LOT of users.

    
script/generate migration add_fb_user_ids

Now edit db/migrate/004_add_fb_user_ids.rb to:

    
class AddFbUserIds < ActiveRecord::Migration
  def self.up
      add_column :recipes, :fb_user_id, :integer
      add_column :comments, :fb_user_id, :integer

      #if mysql
      execute("alter table recipes modify fb_user_id bigint")
      execute("alter table comments modify fb_user_id bigint")
  end

  def self.down
      remove_column :recipes, :fb_user_id
      remove_column :comments, :fb_user_id
  end
end

    
rake db:migrate

We now need to store the facebook user ids in the tables so we’ll add a hidden field to the forms

Add the following to app/views/recipes/new.rhtml and app/views/comments/new.rhtml just before the end of the form

    
<%= f.hidden_field :fb_user_id, :value => @current_fb_user_id %>

We are also going to protect the edit recipe to only allow you to edit your own recipes in app/views/recipes/show.rhtml change

    
    <%= link_to 'Edit', :controller => 'recipes', :action => 'edit', :id => @recipe %> |

    
<%is_my_recipe? @recipe do %>
    <%= link_to 'Edit', :controller => 'recipes', :action => 'edit', :id => @recipe %> |
<%end%>

and add the following to app/helpers/recipes_helper.rb

    
def is_my_recipe?(recipe, &block)
  yield if recipe.fb_user_id.to_i == @current_fb_user_id.to_i
end

See how we cast the facebook user ids to ints. This makes the match actually possible.

Now that was easy but it’s not very Facebooky. Where’s the social? Lets add some friends stuff.

Edit app/controllers/recipes_controller.rb and add the following actions

    
def my
  @title = "My recipes" 
  @recipes = Recipe.find_my_recipes(@current_fb_user_id)

  render :file => "recipes/index", :use_full_path => true
end

def friends
  @title = "Friends recipes" 

  xml_friends_get = fbsession.friends_get
  friend_ids = xml_friends_get.search("//uid").map{|uidNode| uidNode.inner_html.to_i}

  @recipes = Recipe.find_friends_recipes(friend_ids)
  render :file => "recipes/index", :use_full_path => true
end

Add the following to your Recipe model at app/models/recipe.rb

    
class << self

def find_my_recipes(fb_user_id)
  find(:all, :conditions => ['fb_user_id = ?', fb_user_id])
end

def find_friends_recipes(friends_fb_ids)
  find(:all, :conditions => ['fb_user_id IN (?)', friends_fb_ids])
end

end

You can see how we use the facebook API through the rfacebook fbsession.friends_get. This then returns Hpricot XML which we parse to get all the friends of the current user and then look for any Recipes they have created. lets just add these actions to some basic navigation.

Edit app/views/layouts/index.rhtml and include the following just under the body tag

    
    <div id="navigation">
<%= link_to 'All recipes', :controller=>'recipes'%> | 
<%= link_to 'My recipes', :controller=>'recipes', :action => 'my'%> | 
<%= link_to 'Friends recipes', :controller=>'recipes', :action => 'friends'%>
    </div>

We’re done lets start with script/server and navigate to http://localhost:3000/socialrecipe. Woah did you just get redirected to Facebook. Oh yes! It should be asking you to add your new Facebook application now. Tick keep me logged in and press the Log in to button.

You should now get returned to your local application. This is an example of an External Facebook Application. Try creating a new recipe and check it appears in My Recipes.

Try going to http://apps.facebook.com/socialrecipe/. You should see your application inside Facebook. This is an example of an IFrame Facebook Application.

Your application could now be ready to go, you could deploy your application to a server, submit it to the directory and let people add it. But its still not very facebook’y. We shall now go on and look at turning this into a Canvas application. In a canvas FBML application, instead of embedding your application in an IFrame, Facebook is going to make a proxy request to your application and parse the resulting markup. In this markup it can contain the Facebook Markup Language which can display more Facebook like interfaces and other direct interactions but it does limit you in what markup you can use and what you can achieve.

Now because Facebook needs to make a request to a server it must be accessible to Facebook, hence you can’t just run it on your laptop (or you can if you have a static Ip you could route facebook to). But i’m going to use my excellent RailsMachine serving to deploy the application at http://socialrecipe.liverail.net/. So don’t attempt these next steps unless you can also deploy your server to the world.

First of all we need to switch our layouts if we are in the canvas. So change the app/controllers/application.rb

    
layout 'index'

    
layout :check_fb_layout

def check_fb_layout
  if in_facebook_canvas?
    "index_fbml" 
  else
    "index" 
  end
end

This is going to check if the request is in a facebook canvas and if so render a different layout. So add a new layout at app/views/layouts/index_fbml.rhtml

    
<fb:dashboard>
  <fb:header decoration="add_border" icon="false">Liverail Recipes</fb:header>
  <fb:create-button 
href="<%= url_for(:controller => 'recipes', :action => "new", :only_path => true) %>">
New Recipe</fb:create-button>    
</fb:dashboard>
<fb:tabs>
  <fb:tab_item 
href="http://apps.facebook.com<%= url_for(:controller => 'recipes', :action => "index", :only_path => true) %>" 
title="All Recipes"></fb:tab_item>
  <fb:tab_item 
href="http://apps.facebook.com<%= url_for(:controller => 'recipes', :action => "my", :only_path => true) %>" 
title="My Recipes">My Recipes</fb:tab_item>
  <fb:tab_item 
href="http://apps.facebook.com<%= url_for(:controller => 'recipes', :action => "friends", :only_path => true) %>" 
title="Friends Recipes">Friends Recipes</fb:tab_item>
</fb:tabs>

<%unless flash[:notice].blank? %>
<fb:status><%= flash[:notice] %></fb:status>
<%end%>

<%= yield  %>

This will add a Facebook navigation tabs. Notice how the fb:create-button_ works fine with a relative URL but the fb:tab_item requires an absolute url with the http://apps.facebook.com, this is one of the many oddities with FBML. Additionaly we must surround the fb:status with a check because it won’t work if you have a blank tag.

We now need to render different markup for our pages.

Add the following to app/controllers/application.rb

    
      def render_facebook(template = default_template_name)
        if in_facebook_canvas? #or true
           render :action => "#{template}_fbml" 
        else
           render :action => "#{template}" 
        end
      end

You now need to add a call to render_facebook at the end of actions index, show, new, edit for the recipes controller, add a call to render_facebook “index” at the end of actions my, friends for the recipes controller and finally render_facebook at the end of actions new for the comments controller.

Lets create some FBML rendering templates.

First app/views/recipes/index_fbml.rhtml

    
        <fb:header decoration="add_border" icon="false"><%= @title %></fb:header>
        <%@recipes.each do |recipe| %>
            <div>
            <h3><%= link_to h(recipe.title), :controller => 'recipes', :action => 'show', :id => recipe%></h3>
            <p>
                      <fb:profile-pic uid="<%= recipe.fb_user_id %>" size="thumb" />
                      <fb:name uid="<%= recipe.fb_user_id %>" ifcantsee="anonymous" />
                       </p>
            <p><%=h recipe.summary %></p>
            </div>
        <%end%>

app/views/recipes/new_fbml.rhtml

    
        <fb:header decoration="add_border" icon="false">New Recipe</fb:header>
        <%unless @recipe.errors.blank?%>
        <fb:error><%= error_messages_for :recipe %></fb:error>
        <%end%>

            <% form_for(:recipe, :url => {:controller => 'recipes', :action => 'create'}) do |f| %>
              <dl>
                  <dt><label for="recipe_title">Title:</label></dt>
                <dd><%= f.text_field :title %></dd>
                <dt><label for="recipe_summary">Summary:</label></dt>
                <dd><%= f.text_area :summary %></dd>
                <dt><label for="recipe_ingredients">Ingredients:</label></dt>
                <dd><%= f.text_area :ingredients %></dd>
                <dt><label for="recipe_instructions">Cooking Instructions:</label></dt>
                <dd><%= f.text_area :instructions %></dd>
                <dt><label for="recipe_cooking_time">Cooking Time:</label></dt>
                <dd><%= f.text_field :cooking_time %> mins</dd>
                <dt></dt>
                <dd><%= submit_tag "Create" %></dd>
              </dl>
            <%= f.hidden_field :fb_user_id, :value => @current_fb_user_id %>
            <% end %>

        <br/>
        <%= link_to 'Back', :controller => 'recipes' %>

app/views/recipes/edit_fbml.rhtml

    
        <fb:header decoration="add_border" icon="false">Edit Recipe</fb:header>
        <%unless @recipe.errors.blank?%>
        <fb:error><%= error_messages_for :recipe %></fb:error>
        <%end%>

        <% form_for(:recipe, :url => {:controller =>'recipes', :action => 'update', :id => @recipe}) do |f| %>
        <dl>
            <dt><label for="recipe_title">Title:</label></dt>
            <dd><%= f.text_field :title %></dd>
            <dt><label for="recipe_summary">Summary:</label></dt>
            <dd><%= f.text_area :summary %></dd>
            <dt><label for="recipe_ingredients">Ingredients:</label></dt>
            <dd><%= f.text_area :ingredients %></dd>
            <dt><label for="recipe_instructions">Cooking Instructions:</label></dt>
            <dd><%= f.text_area :instructions %></dd>
            <dt><label for="recipe_cooking_time">Cooking Time:</label></dt>
            <dd><%= f.text_field :cooking_time %> mins</dd>
            <dt></dt>
            <dd><%= submit_tag "Update" %></dd>
        </dl>
        <% end %>

        <br/>
        <%= link_to 'Show', :controller => 'recipes', :action => 'show', :id =>@recipe %> |
        <%= link_to 'Back', :controller => 'recipes' %>

app/views/recipes/show_fbml.rhtml

    
<fb:header decoration="add_border" icon="false">
<%=h @recipe.title %>
</fb:header>
<fb:profile-pic uid="<%= @recipe.fb_user_id %>" size="normal" /> 
<fb:name uid="<%= @recipe.fb_user_id %>" ifcantsee="anonymous" />
<p><%=h @recipe.summary %></p>

<h2>Ingredients:</h2>
<p><%=h @recipe.ingredients %></p>

<h2>Instructions:</h2>
<p><%=h @recipe.instructions %></p>

<p><em>Cooking time is around <%=h @recipe.cooking_time %> mins</em></p>

<div id="comments">
    <h2>Displaying <%=pluralize(@recipe.comments.size, 'comment')%></h2>
    <%= link_to 'New comment', :controller => 'comments', :action => 'new', :recipe_id => @recipe %>
       <% @recipe.comments.each do |comment| %>
           <div>
                <fb:profile-pic uid="<%= comment.fb_user_id %>" size="thumb" />
            <p><%= comment.body %></p>    
                posted <%= time_ago_in_words(comment.created_at)  %> 
ago by 
<strong>
<fb:name uid="<%= comment.fb_user_id %>" ifcantsee="anonymous" />
</strong>
            </div>
       <%end %>
</div>

<br/>
<%is_my_recipe? @recipe do %>
    <%= link_to 'Edit', :controller => 'recipes', :action => 'edit', :id => @recipe %> |
<%end%>
<%= link_to 'Back', :controller => 'recipes' %>

app/views/comments/new_fbml.rhtml

    
<fb:header decoration="add_border" icon="false">New Comment</fb:header>
<%unless @comment.errors.blank?%>
<fb:error><%= error_messages_for :comment %></fb:error>
<%end%>

<% form_for(:comment, :url => {:controller => 'comments', :action => 'create'}) do |f| %>
<dl>
    <dt><label for="comment_body">Body Content:</label></dt>
    <dd><%= f.text_area :body %></dd>
    <dt></dt>
    <dd><%= submit_tag "Create" %></dd>
</dl>
    <%= f.hidden_field :recipe_id, :value => @comment.recipe_id %>
    <%= f.hidden_field :fb_user_id, :value => @current_fb_user_id %>
<% end %>

<br/>
<%= link_to 'Back', :controller => 'recipes', :action => 'show', :id => @comment.recipe_id %>

Now i’m all done. I’m deploying my application to socialrecipe.liverail.net using capistrano and their great 5 min app deployment but you use whichever method you do to deploy your application (remember to install the rfacebook gem on your server). Once that is done you need to change the application settings in Facebook. Log on to Facebook and go the Developer application > See my apps > Edit Settings. Now change the Callback URL from http://localhost:3000/socialrecipe/ to http://socialrecipe.liverail.net/socialrecipe/ with your own names of course. Now click the Use FBML radio button and save

Go to http://apps.facebook.com/socialrecipe. Done! Ruby on Rails Facebook application.

It isn’t the best looking but you can style to your heart’s content. Go to here if you want to add my demo application and play it. In the next part of this tutorial we can do some cool stuff with events and profiles.

UPDATE: The second part can be found here

Broadening the Enterprise 2.0 remit with mashups

2007-06-24T10:23:00Z

InfoQ has a great presentation Mash-ups Meet the Enterprise by Rodney Smith at IBM discussing the application of web2.0 technologies within the corporate firewall. This is nothing new and has been an explosive topic since my post in February 2006 Enterprise 2.0

What is interesting are the areas beyond the typical talk of Enterprise blogs and Wikis and taking about the “personal mash-up” which relates to my first and second points of Enterprise 2.0

Delivering all off the company information as addressable discoverable sources.
Allow custom mash-ups of this information on a user-by-user basis

It’s the second point which Rodney Smtih is talking about. The ability for all users in the Enterprise to create their own mash-ups of corporate and web data and deliver the information they need independent of a companies IT departments. A so called “do-it-yourself” IT or Enterprise Mash-up.

Rodney Smith also talks about making your corporate information “mashable” which relates to my first point of addressable discoverable sources.

I think software like this is appearing on the larger web and will move swiftly into the Enterprise. Sites such as Yahoo pipes and Ning.

The problem with these kinds of user created applications is the likely backlash from corporate IT departments who are used to gate-keeping this kind of development. Instead IT needs to focus on the problems which need to be solved to create this kind of environment. This would include middleware and identity services.

So does this fall-in Andrew McAfee’s definition of Enterprise 2.0?

“Enterprise 2.0 is the use of emergent social software platforms within companies, or between companies and their partners or customers.”

The answer. Absolutely. Social software platforms is not limited to blogs, wiki’s and friends networks but a few more ranging remit. I like McAfee’s definition, it doesn’t try to be all inclusive but does focus the term more clearly than the scatter-gun that is web 2.0. The personal mashup will be the use of a social software platform.