Ruby Challenge - a chain of methods and a lazy assessment

Question

After reading the article http://jeffkreeftmeijer.com/2011/method-chaining-and-lazy-evaluation-in-ruby/, I started looking for the best solution for a chain of methods and a lazy assessment.

I think I encapsulated the main problem with the five specifications below; can anyone get them all passing?

Everything goes: subclasses, delegation, meta-programming, but not recommended for the latter.

It would be beneficial to keep dependencies to a minimum:

require 'rspec' class Foo # Epic code here end describe Foo do it 'should return an array corresponding to the reverse of the method chain' do # Why the reverse? So that we're forced to evaluate something Foo.bar.baz.should == ['baz', 'bar'] Foo.baz.bar.should == ['bar', 'baz'] end it 'should be able to chain a new method after initial evaluation' do foobar = Foo.bar foobar.baz.should == ['baz', 'bar'] foobaz = Foo.baz foobaz.bar.should == ['bar', 'baz'] end it 'should not mutate instance data on method calls' do foobar = Foo.bar foobar.baz foobar.baz.should == ['baz', 'bar'] end it 'should behave as an array as much as possible' do Foo.bar.baz.map(&:upcase).should == ['BAZ', 'BAR'] Foo.baz.bar.join.should == 'barbaz' Foo.bar.baz.inject do |acc, str| acc << acc << str end.should == 'bazbazbar' # === There will be cake! === # Foo.ancestors.should include Array # Foo.new.should == [] # Foo.new.methods.should_not include 'method_missing' end it "should be a general solution to the problem I'm hoping to solve" do Foo.bar.baz.quux.rab.zab.xuuq.should == ['xuuq', 'zab', 'rab', 'quux', 'baz', 'bar'] Foo.xuuq.zab.rab.quux.baz.bar.should == ['bar', 'baz', 'quux', 'rab', 'zab', 'xuuq'] foobarbaz = Foo.bar.baz foobarbazquux = foobarbaz.quux foobarbazquuxxuuq = foobarbazquux.xuuq foobarbazquuxzab = foobarbazquux.zab foobarbaz.should == ['baz', 'bar'] foobarbazquux.should == ['quux', 'baz', 'bar'] foobarbazquuxxuuq.should == ['xuuq', 'quux', 'baz', 'bar'] foobarbazquuxzab.should == ['zab', 'quux', 'baz', 'bar'] end end 

Answer 1

Trivial, right?

 class Foo < Array def self.bar other = new other << 'bar' other end def self.baz other = new other << 'baz' other end def bar other = clone other.unshift 'bar' other end def baz other = clone other.unshift 'baz' other end end 

The to_s criterion fails because 1.9 has changed the way Array#to_s . Change this for compatibility:

 Foo.baz.bar.to_s.should == ['bar', 'baz'].to_s 

I want a cake.

BTW - metaprogramming here would reduce code size and greatly increase flexibility:

 class Foo < Array def self.method_missing(message, *args) other = new other << message.to_s other end def method_missing(message, *args) other = clone other.unshift message.to_s other end end 

Answer 2

This inspires Amadan's answer, but uses fewer lines of code:

 class Foo < Array def self.method_missing(message, *args) new 1, message.to_s end def method_missing(message, *args) dup.unshift message.to_s end end