Watchr is a continuous-testing tool by Martin Aumont in the vein of Autotest (part of the ZenTest package).

At its heart, Watchr basically watches any (or all!) of your project’s files, then executes arbitrary Ruby code of your choice when things change.  Watchr configuration takes such a form:

watch(‘pattern’) { |match_data_object| command_to_run }

For example, to produce Autotest-like functionality, you’d just specify Watchr to run the tests whenever a test or some library code changes, like this (taken from Martin’s blog post):

watch(‘test/test_.*\.rb’) { |md| system “ruby #{md[0]}”}
watch(‘lib/(.*)\.rb’) { |md| system “ruby test/test_#{md[1]}.rb”}

…but Watchr can be used for much more than just testing. Read More

Evan Light has recently pushed his Coulda project to Github – it’s a test framework based on Test::Unit, inspired by Cucumber, Shoulda and Thor.

Coulda works like Cucumber in that it’s a Domain Specific Language for capturing the behaviour expected by your code, as part of the Behavior Driven Develoment approach (BDD). Others have noted it’s a little like the RSpec story runner.

Where Coulda differs is that instead of using Gherkin to convert your statements about the behavior to code using regular expressions, it uses standard method calls. This is less of a cognitive leap for the developer… Read More

I have been contemplating the use of document-stores in my Ruby apps for a few months (you might remember my MongoMapper post from back in June), and I’ve been following developments in the No-SQL movement. George Palmer’s presentation at Rails Underground on his couch_foo gem inspired me to explore the possibilities further, and I’ve recently started work on incorporating CouchDB into some projects that I’m working on.

What is a “document store?”

Couch is one of several available document oriented databases (the other main contender being MongoDB, for which there’s a good comparison on the Mongo website). Document stores go some way to bridging the gap between traditional functionality-rich relational databases (like MySQL, Postgres) and fast, highly scalable key/value stores (such as Toyko Cabinet). Read More

I recently came across the interesting-looking Monk framework. It allows you to specify a list of dependencies for technologies to use in your project (in the form of git repositories or gems), and it will take care of extracting them into your application’s vendor folder.

With the default skeleton (for which you’ll need a Redis key/value database installed), you’ll get a Sinatra application with Haml, Rack, Contest, Stories, Webrat and Ohm. However, you can create your own skeleton with its own dependencies if you like.

You can install Monk with:

gem install monk

… and then initialize a project with the default skeleton:

monk init myapp

This will give you a familiar structure with helpers, models, routes, views, lib and vendor folders. Read More

Simone Carletti of Altura Labs recently announced on his blog the release of a new pure-Ruby Whois library, inventively named “Whois“.

He needed a whois library for one of his projects, but found that the existing options didn’t satisfy his requirement of being able to query both IP addresses and top level domains.  Simone’s offering replaces the original whois gem by Cyril Mougel, with which it’s backward compatible.

Using the ‘all-in-one’ whois class-method will give you the default behaviour, with a timeout of 5 seconds. If you want more control you can initialize a new instance of the client:

Whois.whois(“rubyinside.com”)
# =whois response for rubyinside.com

client = Whois::Client.new
client.timeout = 3
client.query(“74.125.67.100″)
# =whois response for 74.125.67.100

For more details, check out Simone’s blog post, the docs, and the Github repository. Read More

Bowline is a new MVC GUI framework for developing cross-platform desktop applications using Ruby, HTML, CSS and Javascript. The author, Alex MacCaw, aims to make building a desktop app as simple as creating a Rails site.

Unlike pure Ruby desktop libraries like Shoes, Bowline builds on Appcelerator Titanium, an SDK for building desktop apps that basically gives you a Webkit window and a set of APIs for interacting with various operating systems. This lets you develop for the desktop using familiar web technologies, including CSS3 and HTML5 (think Adobe Air!).

To allow your Ruby code to interact with your HTML, Bowline introduces the concept of “binders” which can update your views as the underlying data changes (a bit like controllers in Rails). Read More

Like Ryan Sonnek, I’ve dabbled with a few different ways to run background processes in my Ruby apps, even resorting to knocking together my own (far from perfect) solution. As Ryan says on his blog, many popular libraries have complicated interfaces and don’t “feel right”.

I tend to disagree, however, with his statement that every ruby background job solution sucks, and I’m sure he doesn’t really mean it. Although his offering, Backgrounded, is refreshingly simple and concise, it’s effectively just a wrapper for other solutions.

With Backgrounded, if you want a certain method to always run in the background, you can specify it like this:

class User
backgrounded :do_stuff

def do_stuff
# do all your work here
end
end

…and then just call that method in the normal way. Read More