BuffaloFeeds » Ruby Inside

Ruby Inside (10 unread)

Easy Web Spidering in Ruby with Anemone

Posted: July 2nd, 2009, 2:40pm MDT by Ric Roberts
Anemone is a free, multi-threaded Ruby web spider framework from Chris Kite, which is useful for collecting information about websites. With Anemone you can write tasks to generate some interesting statistics on a site just by giving it the URL.

Its only dependency is Nokogiri (an HTML and XML parser). Other than that, you just need to install the gem to get started using Anemone's simple syntax which, among other things, allows you to tell it which pages to include (based on regular expressions) or define callbacks.

This example taken from Anemone's homepage prints out the URL of every page on a site:
```
require 'anemone'

Anemone.crawl("http://www.example.com/") do |anemone|
  anemone.on_every_page do |page|
    puts page.url
  end
end
```
The bin folder in the project contains some more in-depth examples, including tasks for counting the number of unique pages on a site, the number of pages at a certain depth in a site, or a list of urls encountered. There's also a combined-task which wraps up a few of these, intended to be run as a daily cron job.

You can install Anemone as a gem or get the source from Github of course, and there's some fairly comprehensive RDoc documentation available in the source or online.
Also worth seeing.. Mobile Orchard's Beginning iPhone Programming Workshop. Bay Area/July 30-31. Seattle/Aug 20-21. Ruby Inside discount of $200 -- use "ri" discount code.
Integrity: A Fun And Easy Continuous Integration Server

Posted: July 1st, 2009, 9:10am MDT by Matt Sears

Integrity is a simple and lightweight Continuous Integration server written in Sinatra (a DSL for quickly creating web-applications in Ruby). When commits are pushed to a Git repository, Integrity builds, runs tests, and reports the build status to each team member. It supports a variety of notifiers including Email, IRC, and Twitter.

When it comes to developing large projects with multiple team members, it’s common nowadays to set up a Continuous Integration (CI) server. CI is a development practice where developers combine their work frequently and run tests over the whole project in order to identify errors early. Wikipedia has a good summary of the practice.

Integrity makes it easy to setup a CI server for your Ruby apps. It lowers the barrier for people starting out with Continuous Integration, as well as provide a simpler and minimal alternative. The project’s homepage includes helpful installation instructions for Phusion Passenger, Thin, and Heroku.
Matt Sears is a Ruby developer and co-founder of Littlelines, a Rails development and web design company.
Getting Started with MongoDB and Ruby

Posted: June 30th, 2009, 5:45pm MDT by Ric Roberts

MongoDB a is a high-performance, open source, schema-free, document-oriented database written in C++. It's sort of a cross between scalable key/value stores and traditional functionality-rich relational databases.

MongoDB might be useful as a fast, simple, non-transactional data store for a web application, or as a caching mechanism. You don't ever need to worry about migrations due to Mongo's schema-less nature.

Getting started with MongoDB using Ruby is now fairly straightforward thanks to the Mongo Ruby driver. This provides access to the core Mongo database operations, and natively supports many Ruby objects without requiring conversion (including nested hashes). There's even an ActiveRecord connection adapter for Mongo.

Earlier this week, John Nunemaker announced his MongoMapper, a wrapper for MongoDB which includes typecasting, callbacks, validations and other ActiveRecord-like features. The project is heading towards drop-in Rails compatibility.

MongoMapper uses a default connection from the Ruby driver, and to create a MongoMapper model you just need to include MongoMapper::Document in the class (as opposed to ActiveRecord's inheritance pattern). From there, it's simple to define your document's keys, validations and callbacks.

The MongoMapper gem is available from RubyForge or Github, and you can read more on RailsTips.
Also worth seeing.. Mobile Orchard's Beginning iPhone Programming Workshop. Bay Area/July 30-31. Seattle/Aug 20-21. Ruby Inside discount of $200 -- use "ri" discount code.
Hirb: An Easy-to-Use View Framework for irb

Posted: June 28th, 2009, 1:23pm MDT by Ric Roberts

The Interactive Ruby Shell (irb) and the Rails console are great for interacting and experimenting with your ruby application code, but sometimes it's hard to visualize the output. Gabriel Horner has come to the rescue with Hirb: a 'mini view framework' for irb which is designed to improve the default output to make it more human-readable.

Hirb does this by formatting console output according to its type, and paging if there's more than a screenful to display. For example, Hirb will automatically display ActiveRecord model instances in a non-wrapping, table-like view.
irb>> Tag.last +-----+-------------------------+-------------+ | id | created_at | description | +-----+-------------------------+-------------+ | 907 | 2009-03-06 21:10:41 UTC | blah | +-----+-------------------------+-------------+ 1 row in set
There's also a helper provided which displays a collection of arrays or hashes as a tree. This might be useful for visualizing class inheritance trees, nested classes or relationships between ActiveRecord models (as this blog post describes).

In addition to the defaults you can specify your own reusable views, as the author explains in the documentation, leading you through an example of displaying hashes as YAML.

Hirb prints to the standard output by default, but you can configure it to write to anywhere you like, such as a log file.

The source code is on Github (or it can be installed as a gem), with documentation available on the author's site. Hirb users are invited to share any views they have written by forking the Github repository and adding them into the project structure.
Interesting Ruby Tidbits That Don’t Need Separate Posts #26

Posted: June 22nd, 2009, 11:40am MDT by Peter Cooper

The latest installment of the series of posts crammed with random Ruby links, articles, and resources to kick off your week!

17 High Quality Videos from GoGaRuCo
Earlier this month, the videos from the GoGaRuCo (Golden Gate Ruby Conference) conference that took place back in April went online. The talks are all available in MPEG 4 video and MP3 audio formats. Video and audio quality are really good overall (no annoying humming or reverb that often plague such undertakings).

Talks include Using Ruby to Fight AIDS, MacRuby and HotCocoa, Building Custom Web Proxies in Ruby, and Sinatra: The Framework Within, although there are 17 to check out overall.

Phusion Passenger 2.2.4 Released - Stability and Bug Fixes
Yesterday Phusion released version 2.2.4 of Passenger - the de facto Rails and Rack-based Web app deployment module for Apache and nginx. It's the latest in a line of security and stability releases so you might want to get up to date. Crucially, a 8KB-per-request memory leak has been fixed since 2.2.3. Upgrading is as easy as with all previous point releases.

"Enterprise" Ruby - Write Ruby in XML?
Perhaps the most horrible Ruby project I've seen in some time but, luckily, an entirely tongue in cheek one - Enterprise by Aaron Patterson (of Nokogiri fame). Enterprise suggests that writing Ruby in XML yields all sorts of "enterprise" benefits. I wasn't going to link to it, but it blew up on both Reddit and del.icio.us, so someone must find it entertaining. If it keeps Aaron entertained enough to keep developing awesome libraries like Nokogiri, I'm grudgingly for it..
Eventful - Improvements for Observable, Adding Events To Your Objects
Eventful is a small extension for Ruby's Observable module that adds named events, block listeners and event bubbling features. If you haven't used Observable before, it basically provides a simple mechanism for objects to inform other objects of state changes - Eventful builds upon that basic functionality. The basic Eventful page has a few simple examples to whet your appetite.

Free Rack & Rails Metal Screencast
Gregg Pollack of RailsEnvy has produced a new, free screencast for the New Relic RailsLab site called Rack & Metal. In about twenty minutes Gregg covers the basics of Rack and Rack middleware before moving on to showing how Rack fits into the Rails stack. It's a great primer if Rack and Rails Metal are still new to you or you want to see how they fit together in the grand scheme of things.
Publish Your Ruby Documentation on Github with Rdoc.info

Posted: June 19th, 2009, 1:40pm MDT by Peter Cooper

This post is by Matt Sears of Littlelines.

Rdoc.info is simple web service that uses YARD (a documentation generation tool for Rubyists) to generate documentation for Ruby libraries hosted on Github. If you’re not familiar with YARD, it allows you to add metadata to Ruby documentation similar to other languages such as Java and Objective-C. Another cool thing about YARD is its extensibility and allowing you to plug in custom handlers and output.

Rdoc.info, announced in April, was launched as a side project by Nick Plante. Nick leveraged Github’s post-receive-hooks to automatically generate and host Ruby documentation each time a Github project receives a commit. As a standalone work, Rdoc.info is a smart and simple idea. But wait, there’s more!

Nick teamed up with Jeff Rafter and took the project a step further by making the documentation available on Github itself. Jeff put together Github Has An Apps Platform, a splendid article on how they made this possible. The end result, a sleek RDoc browser hosted at docs.github.com allowing you to quickly view methods, namespaces, and the source code all within Github.

While still young, this project shows a lot of promise. Many popular Ruby libraries have already added their documentation to Github. Projects like Rack, Rspec, and Sinatra to name a few.

To get your documentation on Github, check out the instructions available on the docs.github.com.
Also worth seeing.. Mobile Orchard's Beginning iPhone Programming Workshop. Bay Area/July 30-31. Seattle/Aug 20-21. Ruby Inside discount of $200 -- use "ri" discount code.
Generate Ruby Profiling Charts With Perftools

Posted: June 17th, 2009, 2:03pm MDT by Peter Cooper

Ilya Grigorik has written an interesting article called Profiling Ruby with Google's Perftools about using a port of Google's Perftools (perftools.rb) to build graphs showing the results of profiling sessions on your Ruby code. As with all of Ilya's great posts, it's punchy and to the point.

Ilya starts by explaining what Perftools is and shows how to use its regular profiling features from Ruby, which are impressive enough, but then moves on to showing how to generate graphic profiling charts that graphically demonstrate where your application is spending most of its time. Aman Gupta, the developer of Perftools.rb, has produced such graphs for RubyGems, Merb, Rails, and EventMachine, which you might find interesting. Unsurprisingly, Rails and Merb apps seem to spend most of their time at the IO stage.
Job! Interkonect, a web app consultancy in Nottingham, UK, is looking for a part-time junior Rails developer - working from home/freelancing is fine but you should be in the UK in order to attend occasional meetings. Click here to learn more.
Rip: A Next Generation Ruby Packaging System - Watch Out RubyGems!

Posted: June 12th, 2009, 3:55pm MDT by Peter Cooper

Earlier this week, Rip quietly made its way into the world. It's a "next generation" Ruby packaging system, clearly meant to both work around some of the problems with RubyGems and also introduce some fresh ideas of its own. If you want to immediately jump and learn more, check out the official About us page for a tour.

Rip comes from the Github and Sinatra stables with the primary contributors being Chris Wanstrath, Jeff Hodges, Tom Preston-Werner, John Barnette, Blake Mizerany, Ryan Tomayko and Pat Nakajima. This is no "crazy renegade" project, although the developers are keen to stress the existing version is only a "development alpha" to be tested and built upon - not used in production.

Rip has a number of compelling features that make it worth considering for the future. Firstly, it provides another level of abstraction above existing RubyGems, Git repositories, and file structures, in the form of packages. It also supports the creation of virtual environments that can exist simultaneously but wherein different sets of libraries can be installed. Taking a cue from Git, Rip is also decentralized. There's no canonical server for Rip packages - they'll be retrieved from wherever the library developer specifies. This means you won't be able to do anything quite as simple as gem install library, but we're already used to using URLs for other forms of content, so why not library files?

Basically, Rip's a new tool with a whole new way of looking at Ruby packaging and library distribution, but it has a killer team behind it, some solid ideas, and it could well supersede RubyGems in many ways in the near future. We've had rapid tool switches before in the Ruby world (think how quickly Git became entrenched) so I wouldn't be surprised if Rip becomes a big deal over the next several months..
Also worth seeing.. Beginning iPhone Programming Workshop For Rubyists. A companion class to the FutureRuby conference. Toronto, July 9-10, ~~$1200~~ $699.
Whenever: A Ruby DSL for Defining Cron Jobs

Posted: June 9th, 2009, 3:37pm MDT by Peter Cooper

It has always been a trend with Rubyists to take things that have poor interfaces and give them better ones. Javan Makhmali from Inkling Markets has lived up to this trend, and given us Whenever, a library that wraps cron's syntax with a Ruby API (cron being a UNIX task scheduling tool).

Whenever can be tightly integrated with Rails (providing application specific commands such as "rake" and "runner" from the API – see an example here), but can also be run as a standalone program. Whenever outputs valid crontab syntax, and can even write the crontab file for you!

Whenever helps you keep your cron jobs with your code so that there is no separation of logic. Since Whenever is a wrapper for cron, however, it's really focused on on UNIX and UNIX-like machines. While there are some cron implementations for Windows, Whenever wasn't really designed for this purpose.

If Whenever is of interest to you, check out the GitHub page, the blog post of Javan's workplace, and the Railscast by Ryan Bates.

Note: This post was written by Ari Brown.
14 Videos from LA Ruby 2009: Some Great Weekend Watching

Posted: June 5th, 2009, 12:23pm MDT by Peter Cooper
LA Ruby was a single track Ruby conference that took place in Los Angeles (Orange County really, but we'll let them off..) at the start of April. The crack conference recording team Confreaks was in attendance and they've released 14 awesome videos from the event. Most of the videos are about 30 minutes long and you can watch them directly in your browser, download HD or SD MP4 files, or subscribe to the iTunes video podcast or Miro feed.

The overall set list:
- Resource Oriented Architecture, and Why it Matters, and How Waves Make it Easier by Dan Yoder
- Journey through a pointy forest: The state of XML parsing in Ruby by Aaron Patterson
- Sequel by Jeremy Evans
- Herding Tigers - Software Development and the Art of War by Danny Blitz
- Scaling 'most popular' lists: a plugin solution by Wolfram Arnold
- Sinatra: The ultimate rack citizen by Blake Mizerany
- Poolparty - jump in the pool, get in the clouds by Ari Lerner and Michael Fairchild
- Managing Ruby on Rails for High Performance by Bill Lapcevic
- Flying Robot: Unmanned Aerial Vehicles Using Ruby and Arduino by Damen Evans and Ron Evans
- Johnson by Aaron Patterson and John Barnette
- Fast and Scalable Front/Back-end Services using Ruby, Rails and XMPP by Pradeep Elankumaran
- Mobilize your Rails Application by Brendan Lim
- Rhodes Framework for Mobile Client Development by Adam Blum
- The Building Blocks of Modularity by Jim Weirich
The only downside to these videos compared to most Confreaks efforts is there's a lot of reverb and buzzing on the audio tracks, but the picture quality is great and ultimately the content wins out.