Subtle

Subtle updates to Ruby that might make some bits of coding (and testing) easier.

This feature exists to make the creation of sets of objects with data easily.

• Create an array of symbols that match the properties on the objects you want, and
• Pass a block that returns an array of arrays with matching data.

records = [:first_name, :last_name].to_objects { 
  [
    ["John", "Galt"], 
    ["Howard", "Roark"],
    ["Dagny", "Taggart"]
  ]}

records[0].first_name  # "John"
records[0].last_name   # "Galt"

records[1].first_name  # "Howard"
records[1].last_name   # "Roark"

records[2].first_name  # "Dagny"
records[2].last_name   # "Taggart"

This feature exists to create a set of hashes with the same properties, but to only defined the keys once.

records = [:first_name, :last_name].to_hashes {
  [
    ["John",   "Galt"   ],
    ["Howard", "Roark"  ],
    ["Dagny",  "Taggart"]
  ]}

records[0][:first_name]  # "John"
records[0][:last_name]   # "Galt"

records[1][:first_name]  # "Howard"
records[1][:last_name]   # "Roark"

records[2][:first_name]  # "Dagny"
records[2][:last_name]   # "Taggart"

This feature exists to make the creation of an object with assignable properties easy.

• Create an array of symbols that match the properties you want on the object.

person = [:first_name, :last_name].to_object

person.first_name = "John"
person.first_name # Will be John
person.last_name = "Galt"
person.last_name # Will be Galt

You can also pass an optional subject to to_object, and the properties will be added to that method.

subject = ClassWithNoName.new
person = [:name].to_object subject

person.name = "John Galt"
person.name # Will be John Galt

This feature was written because I hate wrapping code in begin/rescue/end blocks. If I have a line of code and I don't particularly care if it fails, I have to wrap it in three more lines of care to stop exceptions.

To me, this is most useful in import work or one-off processes where I might want to check to run a small block of code regardless of whether it fails. This could lead to less code not just because of the lost begin/rescue/end lines, but because code can be written without concern of whether it will fail (nil checks, etc.).

person.name = document.at_xpath('./h1').text

# if this call fails then we will move on
-> { person.bio = document.xpath('./div[@class="bio_info"]//span').text }.call_safely

# if this call fails then the second block will be called
-> { person.special = document.xpath('./div[@class="active"]//a')[1].text == "special" }.call_safely { person.special = false }

One thing I liked about C# was the ability to instantiate my objects like this:

var person = new Person() { FirstName = "John", LastName = "Galt" };

This syntax is not built into Ruby syntax today, but it does exist in Rails models. So I took that idea from Rails and wrote an implementation that works like this:

class Person
  params_constructor
  attr_accessor :first_name, :last_name
end

person = Person.new(first_name: "John", last_name: "Galt")

You can also pass a block to the constructor when it is instantiated, like this:

class Person
  params_constructor do
    @first_name = 'Howard'
  end
  attr_accessor :first_name, :last_name
end

person = Person.new(first_name: 'Dagny', last_name: 'Roark')

person.first_name #= Howard

or like this:

class Person
  params_constructor
  attr_accessor :first_name, :last_name
end

person = Person.new(first_name: 'Dagny', last_name: 'Roark') do |p|
  p.first_name = 'Howard'
end

person.first_name #= Howard

I was inspired to write this feature while dealing with some bad Rails code. A programmer wrote a before_filter on ApplicationController that made a big, expensive web service call to pass the users current weather information to the view. This weather information was shown in various places on the site, but there were many pages on the site where the data was not being used at all.

A thought came to me... would it be possible to create an object that does the work to instantiate itself, but only when it is referenced?

Well, this doesn't quite do that, but it's close. It lets you turn this:

  before_filter do
    service = BigExpensiveWeatherService.new
    # we just paid the price right now
    @weather_results = service.an_expensive_web_call
  end

into this:

  before_filter do
    # we haven't paid the price for this call
    @weather_results = -> do
      service = BigExpensiveWeatherService.new
      service.an_expensive_web_call
    end.to_object
  end

With both, you could do this:

  %span
    = @weather_results.temperature

But with the latter, the call to execute the big web service won't be made until .temperature is called. Future calls to methods on @weather_results will use the same object passed from the Proc.

Exception Raised adds the ability to get the exception thrown by a Proc, but without the begin/rescue syntax.

This method can be helpful in tests by providing a one-line way to get the exception thrown.

  exception = -> { raise 'ok' }.exception_raised
  exception.is_a? RuntimeError # true
  exception.message            # 'ok'

  exception = -> { 1/0 }.exception_raised
  exception.is_a? ZeroDivisionError # true

  exception = -> { 1/1 }.exception_raised
  exception.nil? # true