RailsConf '07 and SF geekSessions

The Err Free team will be accepting beers at RailsConf for anyone interested, come find us.

Chris will be talking about his acts_as_cached plugin on Saturday. He promised me it’s gonna be good and he’s not one to disappoint.

Also, if you’re going to be in the Bay area after RailsConf, there’s a three hour session on the 22nd concerning whether Rails can scale.

It’s $15, has smart people talking, and there’s an open bar afterwards…need I say more? Check it out.

Off To RailsConf and @media America

Just breaking radio silence briefly to say that I’m off to the states (again) to speak at RailsConf in Portland 17th-20th then on to @media America in San Francisco for the 21st-28th. I’m going to be doing presentations both called ‘The Mysteries Of JavaScript-Fu’, both with an old skool kung fu theme but quite different aside from that. If you are around in either of these places or have any tips on good skate and sneaker stores then drop me a line….I’m always up for a couple of cold ones or/and sneaker shopping missions.

When I get I’ll be working a load more on Low Pro and blogging more about it. It’s developing quickly at the moment as Prototype picks up momentum and it’s getting some damn good features. In the meantime, you could always check out the trunk and see the new features that have already gone in. Build the trunk release then try as a sneak preview:

$('an_element').wrap('<strong>');

Also, look out for a major new set of features for Event Wax scheduled for release round about the time of @media London.

Semantic CSS and Rapid Development

Jonny LeRoy commented on my post about CSS style with a very astute observation.

Using classes like “float_left” (.float_left { float: left; }) breaks the separation of markup from presentation and makes it difficult to change layouts / looks just by switching stylesheets.

It’s an excellent point. In a follow up email, Jonny pointed me to this W3C tip. The essential point is that CSS class names should answer the question why and not how. A class named red says how something should look. A class named warning would answer why.

After listening to Hampton Catlin speak about Haml on the Ruby on Rails Podcast it really got me thinking about website documents as a DOM rather than a random string. Semantically meaningful CSS is an important element of a well constructed DOM.

Since I’m not a designer by trade, I approach UI work like programming. I do a lot of iterations and continuously distill XHTML to its most terse form. As an agile developer, I want to see results as quickly as possible. Early on this leads to very scary looking views. For example, a snippet from Wiffled:

<% for comment in @player.comments -%>
  <div style="border-bottom: 1px solid #ddd;">
    <p style="margin-top: 1em;">
    <% unless comment.sender.picture.nil? %>
      <%= image_tag comment.sender.picture.public_filename(:thumb), :style=>'float:left;margin-right: 1em' %>
    <% end -%>
  </div>
<% end -%>

Yuck! However, this is exactly how I work. I didn’t plan what I wanted the page to look like, I just wanted it to work. The best way to do this is to utilize the style attribute directly. This gives you the freedom to play around and try new things easily. Some might call it Rapid Development. I just call it GSD.

Of course if I left code in the above state, I wouldn’t be very good at my job. I believe it’s the next step that really separates web developers. Writing good models and controllers will get you straight up developer cred. But writing great views? That’s the specific domain of web developers.

Rails is really great at the M and C of MVC. ERB is nice, but it’s not a leap on par with the rest of Rails. The next big web app innovation will almost have to come in the View space. I highly suspect it will come from the Ruby community because a great view framework will require a lot of opinions. Semantic CSS and rapid development are some of the things I care about, but I’m sure you’ve got lots of concerns of your own.

By: Derek

just fyi, Ubuntu has the utility a2enmod for automagically creating those symlinks for you.

a2enmod rewrite
a2enmod proxy

also note a2dismod, a2ensite, a2dissite

Fun with hpricot

Those who know me personally know that I’m a pretty huge video game nerd. I’ve been wanting to learn hpricot better, so I decided to combine the two interests. I give you vgdod.rb, which goes and scrapes info about Amazon Video Games’ Deal of the Day. It could probably be optimized, and the XPath could likely be better, but it gets the job done!

It was interesting to try to write XPath for HTML that I didn’t control… this was the first time I’ve had that particular joy, and it was a good exercise. I think we (web developers, that is) sometimes forget that other people might want to manipulate our HTML at some point. Anyway, the code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#!/usr/bin/env ruby

%w(rubygems hpricot open-uri shorturl).each {|g| require g}
def fetch(url = '') ; return Hpricot(open("http://www.amazon.com" + url)) ; end

vg_url = fetch.at("a[text()=Video Games]")[:href]
dotd_img = fetch(vg_url).search("img").select {|e| e[:src] =~ /deal-of-the-day/}.first
dotd = fetch(dotd_img.parent[:href])

# title -- platform -- price -- url
printf "%s -- %s -- %s -- %s",
  dotd.at("//div.buying//b.sans").inner_text.strip,
  dotd.search("//b.price").last.inner_text.strip,
  dotd.search("//div[@class=buying]")[3].inner_text.gsub(/(\ |\s|Platform:)/, ''),
  WWW::ShortURL.shorten("http://www.amazon.com#{dotd_img.parent[:href]}")

Fun with hpricot

Those who know me personally know that I’m a pretty huge video game nerd. I’ve been wanting to learn hpricot better, so I decided to combine the two interests. I give you vgdod.rb, which goes and scrapes info about Amazon Video Games’ Deal of the Day. It could probably be optimized, and the XPath could likely be better, but it gets the job done!

It was interesting to try to write XPath for HTML that I didn’t control… this was the first time I’ve had that particular joy, and it was a good exercise. I think we (web developers, that is) sometimes forget that other people might want to manipulate our HTML at some point. Anyway, the code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#!/usr/bin/env ruby

%w(rubygems hpricot open-uri shorturl).each {|g| require g}
def fetch(url = '') ; return Hpricot(open("http://www.amazon.com" + url)) ; end

vg_url = fetch.at("a[text()=Video Games]")[:href]
dotd_img = fetch(vg_url).search("img").select {|e| e[:src] =~ /deal-of-the-day/}.first
dotd = fetch(dotd_img.parent[:href])

# title -- platform -- price -- url
printf "%s -- %s -- %s -- %s",
  dotd.at("//div.buying//b.sans").inner_text.strip,
  dotd.search("//b.price").last.inner_text.strip,
  dotd.search("//div[@class=buying]")[3].inner_text.gsub(/(\ |\s|Platform:)/, ''),
  WWW::ShortURL.shorten("http://www.amazon.com#{dotd_img.parent[:href]}")

Two Ruby Quirks

I stumbled across two Ruby quirks that I'd never seen before. Can these perversions of syntax be put to good use? I hope so (cue evil laugh)!

First up, a special case for method arguments. What do you think this does:

hello:dave

Turns out that it looks for the method hello, and supplies the symbol :dave as the first argument. What's odd about that? Well, not only are there no parenthesis, but there's no space between the method name and the argument. But it works!

1
2
3
4
5

def hello(*args)
  puts args.inspect
end

hello:dave # ==> [:dave]

Weird!

Secondly, and more weirdly, what do you make of this:

1
2
3
4
5

class Hello
end

Hello::dave
# ==> undefined method 'dave' for Hello:Class

Note that we're using the double-colon now. Doing this with a lower-case right hand side (as opposed to the capitalized, constantesque Base in ActiveRecord::Base) will cause Ruby to attempt a call to a method defined on the class itself! It's the same as calling

Hello.dave

Does anyone else find this weird? I've been using Ruby basically full-time since around 2002, but I'd never seen these quirks before...

On a somewhat related note, it's possible to define a method that looks like a constant, and some people use this to create Java-style constructor calls:

1
2
3
4
5
6
7
8
9
10

class Hello
  def initialize(*args)
  end
end

def Hello(*args)
  Hello.new(*args)
end

Hello(:dave)  # ==> #<Hello:0x35233>

So we can now also add

Hello:dave

to our menagerie of odd Ruby syntaxes. I wouldn't really recommend it because it's not "The Ruby Way" and will look weird to anyone who doesn't know about your quirks, but it's fun to know. Actually, I believe _why employs this trick in Camping Routes...

Backup of Bloglines keep new items

If you are a Bloglines user, you probably save the interesting posts using "keep new" feature.

If you have use this reader for a time, the quantity of post saved could be large... Some day I thought that won't be funny to loose all this data, then I build a ruby script to backup bloglines "keep new" items into a xml file.

With this script I learned better Mechanize and Hpricot Ruby libraries.
Este script me ha servido para probar dos librerías muy útiles de Ruby: mechanize y hpricot.

You need these libraries in order to use the script:

gem install json
gem install activesupport
gem install hpricot
gem install mechanize

require "rubygems"
require "hpricot"
require "json"
require "mechanize"
require "active_support"

# Reads a bloglines javascript tree structure that has all
# feeds data.
def read_tree( tree_base, label = "" )
 tree_base.each do |tree|
 if tree["kids"]
  read_tree tree["kids"], label + "/" + tree["n"]
  else
  @feeds << [tree["n"], label, tree["kn"], "http://www.bloglines.com/myblogs_display?sub=#{tree["id"]}&site=#{tree["sid"]}"]
 end
 end
end

# Add more memory to hpricot otherwise couldn't load some webs.
Hpricot.buffer_size = 262144

agent = WWW::Mechanize.new
page = agent.get 'http://www.bloglines.com/login'

form = page.forms[1]
form.email = 'EMAIL'
form.password = 'PASSWORD'

page = agent.submit form

# Get the bloglines sindicated feeds
menu_page = agent.get "http://www.bloglines.com/myblogs_subs"
start_text = "var initTreeData = "
end_text = "\n;\n"
js_feeds_tree_str = menu_page.content[menu_page.content.index(start_text)+start_text.size..menu_page.content.index(end_text)]
feeds_tree = JSON.parse js_feeds_tree_str.gsub("\\","")
@feeds = []
read_tree(feeds_tree["kids"])

puts "<bloglines_saves>"
@feeds.each do |feed|

 page = agent.get feed[3]
 doc= Hpricot(page.content)

 # get the content of all saved feed posts
 content = ((doc/"body")/"td.article")
 next if content.empty?
 puts "<feed name=\"#{feed[0].strip}\" folder=\"#{feed[1].strip}\">"
 
 # Iterate each saved feed post
 ((doc/"body")/"a.bl_itemtitle").each_with_index do |title, index|
  puts "<feed_save title=\"#{title.inner_html.strip}\" href=\"#{title.attributes["href"]}\">"
  puts content[index].inner_html.to_xs
  puts "</feed_save>"
 end
 puts "</feed>"

end
puts "</bloglines_saves>"

• Hpricot: http://code.whytheluckystiff.net/hpricot/
• Mechanize: http://mechanize.rubyforge.org/mechanize/

Capistrano Off the Beaten Path

Introduction

If you use Capistrano, most likely you use it to deploy rails applications by running it from the project directory. The plugem management tool piggy-backs on Capistrano to execute some recipes without using the current path because recipes operate on gems. Recipes do not, however, completely ignore the current directory, but instead use it for optional customization. Customization is not limited to a deployment recipe from the current directory but can be environment-specific across multiple sites if they each have a special extension gem installed.

Background

We use a bunch of ruby scripts at RHG for deployment and delivery of our numerous applications and shared component. When we started preparing some of that functionality for a public release, we needed to provide a way to customize the scripts. Warren Konkel suggested to migrate them to Capistrano since it was the most familiar tool for rails developers and it has a recipes hierarchy that can be used for customization. So, we wrote the plugem command tool that feeds its parameters to Capistrano via Capistrano::CLI.new(plugem_converted_arguments).execute!
after loading its own recipes.

The Code

    1 module Capistrano
    2   class Configuration
    3
    4     alias :standard_cap_load :load
    5
    6     def load(*args, &block)
    7
    8       standard_cap_load(*args, &block)
    9      
   10       if args == ["standard"]
   11
   12         load_plugem_deploy_recipes(File.dirname(__FILE__) + '/../..')
   13
   14         begin
   15           require 'plugems_deploy_ext'
   16           load_plugem_deploy_recipes(PLUGEMS_DEPLOY_EXT_DIR) # Overriding from extensions
   17         rescue Exception
   18           # No extension is loaded
   19         end
   20
   21       end
   22
   23     end
   24    
   25     def load_plugem_deploy_recipes(dir)
   26       Dir[File.join(dir, 'recipes', '*')].each { |f| standard_cap_load(f) }
   27     end
   28      
   29   end
   30 end

Tough love from Verizon

I don’t think you have to be a language snob to wince (and laugh) at the way advertisers misuse English. They’re protected, of course, by the myths that surround their profession. If they get their grammar wrong, or misuse an idiom, they must have some ingenious marketing reason for doing so—or so people are willing to asusme. In fact, I think what’s happening is that the lousiness of the American educational system is trickling up into the ranks of copy writers and copy editors and basically everyone in the chain of custody of commercials.

The one that got me writing this post is a Verizon radio ad, specifically an ad for Verizon’s phone/cable/Internet triple package. It features the usual fake testimonial sound-bites from actors pretending to be customers. That’s par for the course, until one of them says (and the stuff in square brackets is a paraphrase; the rest is verbatim):

“[Verizon gives you a great deal,] providing all three services and not pulling any punches.“

I love the image of a Verizon repair person coming to my door and slugging me in the jaw, as hard as he or she can. (I’d rather it not happen, but I love the image.) It is, of course, completely clear that the person who wrote that line has no idea what the expression “pulling a punch� actually means, and neither do the executives who paid to have the ad written. I surmise that they think it means “pulling a stunt�, so that not pulling any punches means you’re entirely honest. Or something. Who knows?

I suppose that if Coors can actually bring to market a product called “Artic [sic] Ice�, then Verizon can sleepwalk through the process of producing radio commercials. In fact, it doesn’t surprise me any more. I no longer expect the ostensible gatekeepers to know what they’re doing. They probably never did, but I do think it’s gotten worse. And funnier.

Talking about distributed Ruby at LRUG tonight

Just a quick note to say that I'll be giving a talk at tonight's London Ruby Users group on distributed Ruby (and Rails.

More details on the event here