BuffaloFeeds » Ruby Inside

Ruby Inside (6 unread)

Last Week’s Top Ruby News: Rails 3.1.3, autoload deprecated, and conferences

Posted: November 28th, 2011, 5:02pm MST by Peter Cooper

It's a couple of days late but here are the main headlines from the last week of Ruby news. We have a couple of Rails releases, some event news, and the usual gaggle of great articles and jobs.
Headlines
Rails 3.1.3 Released (Very Quickly After 3.1.2)
This release mainly contains fixes for regressions that popped up in 3.1.2, including a downgrade to Sprockets. 3.1.2 itself was primarily a bug and security fix release and cleared up a XSS vulnerability in the translate helper.

Rails 3.0.11 Released (clears up aforementioned security vuln too)

Matz says 'Autoload will be dead' (in Ruby 3.0)
Matz says he should have removed 'autoload' from Ruby when he added threads to the language but he has now deprecated them. Due to Ruby 2.0's backwards compatibility demands, though, they won't be fully gone until Ruby 3.0 but Matz now discourages using autoload.

MountainWest RubyConf 2012 Call For Proposals Open
Want to talk at a popular Ruby conference in 2012? MWRC's call for proposals is now open until January 7, 2012. The conference itself takes place in Salt Lake City, Utah on March 15-16, 2012.

Scottish Ruby Conference 2012 Registration Open
You can now buy tickets for June 2012's Scottish Ruby Conference. It's been very popular in the last couple of years so if you fancy going, check it out soon.

Railsclub: A Russian Rails Conference, Moscow, December 17

Heroku Launches Postgres as a SQL Database-as-a-Service
Articles and Tutorials
Configuration for Rails, the Right Way
Mike Perham notes that he still sees people promoting various gems and plugins to handle configuration elements in Rails apps, but that one little known secret is that Rails 3 allows you to define your own configuration elements trivially.

Rails 3.1 Subdomains and Devise Example App and Tutorial
Daniel Kehoe has been working on some interesting Rails demo apps recently and now he presents a detailed Rails subdomains tutorial showing how to create an example Rails 3.1 application with subdomains and authentication using Devise.

Ruby 1.9 Walkthrough: A Bumper Set of Ruby 1.9 Notes
Martin Carel recently bought and watched my Ruby 1.9 video and has put together a bumper set of notes with the main Ruby 1.9 changes outlined.

Unobtrusive Object Deletion in Rails, The Easy Way
Using RESTful routes, the HTTP DELETE verb is necessary to delete resources. But what if your users aren't running JavaScript and want to delete items? Ryan Townsend shows a way to get everything running smoothly.

Using Amazon's CloudFront CDN with Rails

The Rails 3 Asset Pipeline in (about) 5 Minutes
Michael Erasmus was feeling unsure about how the asset pipeline in Rails 3.1 worked but after digging around for a while, he's put together a simple high level overview.

How to Make Gem Patches with Gem Edit

Installing Ruby, Rails, and MySQL on OS X Lion
My Ruby Show co-host Jason Seifer has written a guide to setting up a basic Ruby development environment on Mac OS X Lion over at Think Vitamin.

Admin Interfaces for Rails Apps: RailsAdmin vs ActiveAdmin
Screencasts
Contributing to Open Source (RailsCasts)
In the 300th Railscasts episode, Ryan Bates shows how to submit a pull request to an open source Ruby project on GitHub.

Aaron 'Tenderlove' Patterson's Emoji Test Output Gem
Libraries and code
Faye 0.7: New Event APIs and an Open WebSocket Stack
The latest release of Faye adds a few new event hooks and ships with a stand-alone WebSocket client/server implementation that makes adding WebSockets to any Rack app dead simple.

Ruby Command-Line One-Liners
A large collection of Ruby 'one liners', all set up to run from the command line, to perform various functions, mostly involving processing text files.

Snowday: A Snow Themed RSpec Formatter

rack_mailer: Rack End Point for a Contact Form
rack_mailer is a simple piece of Rack middleware that takes passed parameters and sends an e-mail to a preconfigured address.

An OAuth2 Tutorial Project
Ruby Jobs of the Week
Junior Rails Developer at Harvest [New York, New York]

Ruby/Rails developer - Remote at 12 Spokes [Salt Lake City, Utah]

Ruby and Front-End Web Developers at BenchPrep.com [Chicago, Illinois]
Last but not least..
Ruby Reloaded: Boost Your Ruby-Fu in December with Peter Cooper
My live, online Ruby Reloaded course has its 4th outing on December 5/6 (next week) and only 7 6 seats remain. Learn more about what it's about by following the link and use the code 'INSIDE' to get $50 off.
This Week’s Ruby News: RSpec 2.8.0 RC1, Minitest 2.8.0, and What’s New in Bundler 1.1?

Posted: November 12th, 2011, 9:11pm MST by Peter Cooper

After last week's bumper set of releases the Ruby world seems a lot quieter this week :-) (Even here. I've been hidden away teaching my Ruby Reloaded course!)
Headlines
RSpec 2.8.0 RC1 Released
The next significant release of RSpec is afoot and its first release candidate is now out. Key improvements come to configuration (and being able to override it from the command line) and running examples in random (and pseudo-random) order.

Ruby 1.9.3-p0 RubyInstaller for Windows Available
RubyInstaller is a popular route to installing Ruby for Windows users, and a new version based on the all-new Ruby 1.9.3-p0 is now out.

Ruby Webapp Performance Management Service New Relic Adds Free Server Monitoring

Minitest 2.8.0 Released
Articles and Tutorials
Besides Being Faster, What Else is New in Bundler 1.1?
Recently, Pat Shaughnessy did a great post explaining why the forthcoming Bundler 1.1 will be faster than 1.0. This time around, he looks at some new features, including bundle outdated, bundle clean, specifying install paths, and creating bundles that will work on machines that don't have Bundler installed.

The Current and Future Ruby Platform
Adam Keys shares his thoughts on the long-term future potential of Ruby as a platform and where it's likely and unlikely to go.

A Self Guided Rails 3.1 Tutorial in an App
An interesting app built by Peter Jones that aims to be a self guided Rails 3.1 tutorial. The README is extensive and explains how to get started. There are also some reader exercises designed to stretch your coding muscles.
Screencasts

Be a Minecraft Modman with Purugin
At RubyConf 2011, Thomas Enebo (of JRuby core team) gave a talk about Purugin, a plugin framework for building Minecraft modifications using Ruby.

RailsCasts on the Mercury Editor
Mercury allows you to edit a section of HTML directly in the browser with a WISYIWYG editor. In this week's Railscasts, Ryan Bates shows how to integrate Mercury into a Rails app.
Libraries and code
Likeable: Storing 'Liked' Objects with Redis
Likeable is a new open-source Ruby library built by Gowalla to store 'likes' on items. It works with ActiveRecord objects but can be used with any Ruby object that implements an #id method. If you have Redis ready and waiting, it looks pretty easy to get going.

X11Client: Manage X11 Windows/Events from Ruby (including Mouse Control)

Example Rails 3.1.1 App using Mongoid and OmniAuth 1.0
With OmniAuth 1.0 out just last week, it's great to see Daniel Kehoe has updated his popular Rails 3.1 example app to the latest and greatest. If you want to see how to bring Mongoid and OmniAuth together with Rails 3.1, this is a great place to start.

RBzip2: A Pure Ruby Implementation of the bzip2 (De)Compression Algorithm

Sinatra-Static: Turn a Sinatra App into a Static Site

ZK: A High Level Ruby Interface to Apache ZooKeeper
Ruby Jobs of the Week
Ruby Developer [Cambridge, Massachusetts]
Every programmer at Litmus remembers the first time they searched for an answer to their programming problem, only to realize they were the first to try to take it on. These days, it's an almost daily occurrence around here. If that sounds exciting to you, then we'd like to talk to you.

Rails Developer at EquipRent.com [Scottsdale, Arizona]

Rails Developer (or Rails Enthusiast) Wanted at Legitscript [Portland, Oregon]
Last but not least..
Gemnasium: Keep Up to Date With New Versions of Gems
Gemnasium is a new commercial service (yep, it costs money) that parses your Ruby projects' gem dependencies and notifies you when new versions are released. There's a 2 week trial if you want to get a feel for how it works.
Ruby’s Unary Operators and How to Define Their Functionality

Posted: November 8th, 2011, 10:27am MST by Peter Cooper
In math, a unary operation is an operation with a single input. In Ruby, a unary operator is an operator which only takes a single 'argument' in the form of a receiver. For example, the - on -5 or ! on !true.

In contrast, a binary operator, such as in 2 + 3, deals with two arguments. Here, 2 and 3 (which become one receiver and one argument in a method call to +).

Ruby only has a handful of unary operators, and while it's common to redefine binary operators like + or [] to give your objects some added syntactic sugar, unary operators are less commonly redefined. In my experience, many Rubyists aren't aware that unary operators can be redefined, so this article demonstrates how.
A Quick Example with -@
Let's ease into things with the - unary operator. The - unary operator is not the same thing as the - binary operator (where a binary operator has two operants). By default, the - unary operator is used as notation for a negative number, as in -25, whereas the - binary operator performs subtraction, as in 50 - 25. While they look similar, these are different concepts, different operators, and resolve to different methods in Ruby.

Using the - unary operator on a string in irb:
```
ruby-1.9.3-p0 :001 > -"this is a test"
NoMethodError: undefined method `-@' for "this is a test":String
```
The String class doesn't have unary - defined but irb gives us a clue on where to go. Due to the conflict between the unary and binary versions of -, the unary version has a suffix of @. This helps us come up with a solution:
```
str = "This is my STRING!"

def str.-@
  downcase
end

p str     # => "This is my STRING!"
p -str    # => "this is my string!"
```
We've defined the unary - operator by defining its associated -@ method to translate its receiving object to lower case.
Some Other Operators: +@, ~, ! (and not)
Let's try a larger example where we subclass String and add our own versions of several other easily overridden unary operators:
```
class MagicString < String
  def +@
    upcase
  end

  def -@
    downcase
  end

  def !
    swapcase
  end

  def ~
    # Do a ROT13 transformation - http://en.wikipedia.org/wiki/ROT13
    tr 'A-Za-z', 'N-ZA-Mn-za-m'
  end
end

str = MagicString.new("This is my string!")
p +str         # => "THIS IS MY STRING!"
p !str         # => "tHIS IS MY STRING!"
p (not str)    # => "tHIS IS MY STRING!"
p ~str         # => "Guvf vf zl fgevat!"
p +~str        # => "GUVF VF ZL FGEVAT!"
p !(~str)      # => "gUVF VF ZL FGEVAT!"
```
This time we've not only redefined -/-@, but the + unary operator (using the +@ method), ! and not (using the ! method), and ~.

I'm not going to explain the example in full because it's as simple as I could get it while still being more illustrative than reams of text. Note what operation each unary operator is performing and see how that relates to what is called and what results in the output.

Note: You cannot redefine ! in Ruby 1.8. This code performs as-is in Ruby 1.9 only. If you remove the ! method and examples, the code otherwise works in Ruby 1.8. There's a longer 1.8 and 1.9 example later in this post.
Special Cases: & and *
& and * are also unary operators in Ruby, but they're special cases, bordering on 'mysterious syntax magic.' What do they do?
& and to_proc
Reg Braithwaite's The unary ampersand in Ruby post gives a great explanation of &, but in short & can turn objects into procs/blocks by calling the to_proc method upon the object. For example:
```
p ['hello', 'world'].map(&:reverse)  # => ["olleh", "dlrow"]
```
Enumerable#map usually takes a block instead of an argument, but & calls Symbol#to_proc and generates a special proc object for the reverse method. This proc becomes the block for the map and thereby reverses the strings in the array.

You could, therefore, 'override' the & unary operator (not to be confused by the equivalent binary operator!) by defining to_proc on an object, with the only restriction being that you must return a Proc object for things to behave. You'll see an example of this later on.
* and splatting
There's a lot of magic to splatting but in short, * can be considered to be a unary operator that will 'explode' an array or an object that implements to_a and returns an array.

To override the unary * (and not the binary * - as in 20 * 32), then, you can define a to_a method and return an array. The array you return, however, will face further consequences thanks to *'s typical behavior!
A Full Example for Ruby 1.8 and Ruby 1.9
We've reached the end of our quick tour through Ruby's unary operators, so I wanted to provide an example that shows how to override (or partially override) them that should stand as its own documentation:
```
class MagicString < String
  def +@
    upcase
  end

  def -@
    downcase
  end

  def ~
    # Do a ROT13 transformation - http://en.wikipedia.org/wiki/ROT13
    tr 'A-Za-z', 'N-ZA-Mn-za-m'
  end

  def to_proc
    Proc.new { self }
  end

  def to_a
    [self.reverse]
  end

  if RUBY_VERSION > "1.9.0"
    eval %{def !
      swapcase
    end}
  end
end

str = MagicString.new("This is my string!")
p +str                   # => "THIS IS MY STRING!"
p ~str                   # => "Guvf vf zl fgevat!"
p +~str                  # => "GUVF VF ZL FGEVAT!"
p %w{a b}.map &str       # => ["This is my string!", "This is my string!"]
p *str                   # => "!gnirts ym si sihT"

if RUBY_VERSION > "1.9.0"
  p !str                   # => "tHIS IS MY STRING!"
  p (not str)              # => "tHIS IS MY STRING!"
  p !(~str)                # => "gUVF VF ZL FGEVAT!"
end
```
It's almost a cheat sheet of unary operators :-)
A Further Example: The TestRocket
TestRocket is a tiny testing library I built for fun a few months ago. It leans heavily on unary operators. For example, you can write tests like this:
```
+-> { Die.new(2) }
--> { raise }
+-> { 2 + 2 == 4 }

# These two tests will deliberately fail
+-> { raise }
--> { true }

# A 'pending' test
~-> { "this is a pending test" }

# A description
!-> { "use this for descriptive output and to separate your test parts" }
```
The -> { } sections are just Ruby 1.9 style 'stabby lambdas' but I've (with assistance from Christoph Grabo) added unary methods to them so that you can prefix +, -, ~, or ! to get different behaviors.

Hopefully you can come up with some more useful application for unary methods on your own objects, of course!
The Ruby Standard Library To Be Converted to Gems for Ruby 2.0?

Posted: November 7th, 2011, 6:28am MST by Peter Cooper

The Ruby standard library (a.k.a. stdlib) is a collection of Ruby libraries that, at one time or another, have been considered useful enough to include with the MRI Ruby implementation by standard. Due to the popularity of these libraries, other Ruby implementations have then tended to re-implement or include the standard library too.

As part of the march toward Ruby 2.0, the state of Ruby's 'standard library' has come up for discussion. A popular line of thinking (and IMHO, very likely to actually happen) is that the standard library should be 'gemified' for Ruby 2.0.
Why Gemify the Standard Library?
The standard library approach has a significant flaw. Due to being a large and critical piece of software, MRI's release cycle is slow, yet some libraries require faster updates, perhaps for security or API updates. It would be better, therefore, to have the standard libraries maintained and distributed separately while still being included 'by default' with Ruby implementations.

We have already seen this sort of approach with RubyGems itself. For example, RubyGems is (at the time of writing) at version 1.8.11, yet the barely 2 week old Ruby 1.9.3p0 comes with RubyGems 1.8.10. While RubyGems is not itself distributed as a gem, it demonstrates the value of having something included with Ruby and still updateable separately.
Aaron Patterson (of the MRI Ruby Core Team) Explains
In his talk at RubyKaigi, Aaron tenderlove Patterson spoke about working out which parts of Ruby are 'third party libraries' and how to extract them. After such extraction, Ruby core should be able to commit to or change anything within MRI, but also reference third party gems that are included and installed by default on new installations. Aaron noted that being able to 'iterate faster' was a significant benefit of this approach.

Aaron also explained that with less coupling between Ruby implementations and the libraries they depend upon, it could be possible in future to upgrade your Ruby interpreter while still maintaining existing versions of the libraries you depend upon. This could help you migrate more gradually or merely help you maintain existing compatibility.
Further Reading
The process of gemifying the Ruby standard library is explained on the Ruby implementation wiki with the proposal, implementation, and a list of to do items already laid out. A more extensive discussion (which you can join) is also taking place on the official MRI Ruby issue tracker.

This process is still in its early stages and there are likely to be opportunities to help maintain or even become the maintainer for certain standard libraries, if you want to get involved.
This Week’s Ruby News: Ruby 1.9.3p0, OmniAuth 1.0, MagLev 1.0 and More

Posted: November 5th, 2011, 4:54pm MDT by Peter Cooper

The rapid descent of the weather towards winter is getting people to stay in and code and long may it continue given the quality of this week's releases: OmniAuth 1.0, MagLev 1.0, and Ruby 1.9.3, for starters!
Headlines
Ruby 1.9.3-p0 Released
The first production-ready release of Ruby 1.9.3 is finally here with patchlevel 0's release this week. I've already covered what's new on Ruby Inside (see the link below) but this is a nice step forward for MRI and worth checking out, especially if you want faster Rails loading times.

MagLev 1.0.0 Released
It's been a couple of years in the making but MagLev 1.0.0 has released. MagLev is an interesting Ruby implementation and virtual machine built by VMware's GemStone Systems division that orients itself around a novel object persistence layer. The best part? It's open source and MIT licensed. Expect to see more about this soon.

Ruby 1.9.1 is Dying (Support Ends Jan 31, 2012)
In a post to the ruby-core mailing list, Ruby 1.9 release manager Yuki Sonoda explains that Ruby 1.9.1 will get no official security fixes or releases after January 31, 2012.
Articles and Tutorials
Ruby 1.9.3: What's New and What's Different

A Guide to HTML5 Boilerplate for Rails Developers
The 'HTML5 Boilerplate' serves as a useful reference for Rails developers who want to provide structure and convention for the HTML, CSS, and Javascript of an app's front-end. But not all of HTML5 Boilerplate is useful for Rails developers, so with this guide, by Daniel Kehoe, you can pick and choose the components that are useful for your Rails apps.

Programming With Nothing: Computation with Nothing but Procs
The striking slidedeck from 'Programming With Nothing', a talk given by Tom Stuart at last week's Ruby Manor unconference. It demonstrates how to implement FizzBuzz solely by creating and calling Proc objects, all thanks to the lambda calculus.

Thinking Functionally in Ruby (a slidedeck)

How Do I Create And Publish My First Ruby Gem?

Advanced Server Definitions in Capistrano
Screencasts
Playing with PJAX (from RailsCasts)
PJAX allows you to quickly update a section of a page using AJAX with automatic pushState support (for URL changes). In the latest episode of RailsCasts, Ryan Bates demonstrates how to use the pjax_rails and rack-pjax gems.

14 Talks from the ArrrrCamp 2011 Conference
ArrrrCamp was held in Ghent, Belgium a month ago and now videos of the talks are available. Enjoy Corey Haines demonstrating fast Rails tests, Andrew Nesbitt on A/B split testing, Elise Huard on 'data driven development' and more.

The Ruby 1.9 Walkthrough: Go Deep on Ruby 1.9
The most comprehensive and up to date walkthrough of Ruby 1.9 for existing Rubyists. It's a commercial screencast by me, Peter Cooper. Ruby 1.9 guru James Edward Gray II even said he picked up plenty of stuff from it. There's a 5 minute sample available if you want to see how it works.

Pik Screencast: A Ruby Version Manager for Windows
Glenn Goodrich presents a 15 minute screencast taking a look at the Pik Ruby version manager for Microsoft Windows.
Libraries and code
OmniAuth 1.0: Authentication APIs Reach A New Level
OmniAuth is a popular library for performing authentication against numerous external authentication systems (like OAuth, OpenID, Facebook, and Twitter). Version 1.0 brings massive structural changes (for the better) and even includes capabilities to do your local/internal authentication with OmniAuth too. This is a big deal.

hash_syntax: Converts Ruby Files to and From Ruby 1.9 Hash Syntax
hash_syntax is an interesting little tool that can go through a Ruby project and convert the source either to or from using the new Ruby 1.9 hash literal syntax. It requires Ruby 1.9 to run.

ratelimit: A Redis-backed Rate Limiter for Rubyists

An Introduction to Logging, A New Flexible Logging Library for Ruby

Appraisal: Test Your Libraries Against Dependencies Far and Wide
Appraisal is a testing tool that integrates with Bundler to test your library against different versions of dependencies in repeatable scenarios called 'appraisals.'

capybara-screenshot: Automatic Screenshot when a Cucumber Capybara Scenario Fails

Gaga: A Git-Backed Key/Value Store in Ruby
Ruby Jobs of the Week
Senior Rails Engineers [San Francisco, California]
Sharethrough is looking for senior application engineers to help build out their reporting and trafficking platform. You will play a significant role in designing and architecting the core pieces underlying the entirety of Sharethrough's platform. They're located in SF's Financial District.

Ruby Software Engineer at Square [San Francisco, California]

Senior Rails Engineer at Scribd (World's #2 Rails Site) [San Francisco, California]
Last but not least..
Spree Conference 2012 (Feb 15-16, New York City)
Spree is probably the most popular open source e-commerce solution built on Rails and there's a conference covering both it and Rails generally in NYC next year. There's already an impressive speaker line up, a GitHub sponsored after party, and an evening hackathon.

[ad]Gauges is a real time traffic analytics system so you can analyze all your traffic in seconds. Collect and analyze your web traffic for all your sites in real-time using their fast, reliable, hosted system and see overview data for all your sites on a single page. Click here to learn more.
Screencast: Coding Conway’s Game of Life in Ruby the TDD Way with RSpec

Posted: November 1st, 2011, 6:25pm MDT by Peter Cooper

Recently, there have been many screencasts of people coding things in real time. Yesterday, Ryan Bigg released a video of him implementing Conway's Game of Life from scratch by reading through the 'rules' and then using RSpec to take a test driven approach to fleshing out the functionality.

Ryan is a Ruby Hero and technical writer best known for being co-author of the recently released Rails 3 in Action (along with Yehuda Katz) which I'll be reviewing soon for Ruby Inside. But Ryan's also been getting into doing a little screencasting:

If you can't see the video above, view it directly on Vimeo here.

Ryan's technique is just one of many legitimate approaches but many of you will find something to pick up from this, especially if you're not familiar with test driven development or, perhaps, RSpec. If you're already working on koans non-stop and consider yourself well versed in the ways of TDD, you might want to skip it.

The only downside is that Ryan focuses entirely on the logic without doing a live render of the game board to see his work in action, though this was the right rational choice given the time limit. That would make a good separate project to follow on with, though, if you fancy a little challenge, but be careful to not couple the game logic tightly to any interface you choose to try.