रूबी चैलेंज - विधि चेनिंग और आलसी मूल्यांकन

Question

आलेख http://jeffkreeftmeijer.com/2011/method-chaining-and-lazy-evaluation-in-ruby/ लेख पढ़ने के बाद, मैंने विधि श्रृंखला और आलसी मूल्यांकन के लिए एक बेहतर समाधान की तलाश शुरू कर दी।

मुझे लगता है कि मैंने नीचे पांच चश्मा के साथ मूल समस्या को समाहित किया है; क्या कोई उन्हें सब गुजर सकता है?

कुछ भी जाता है: सबक्लासिंग, प्रतिनिधिमंडल, मेटा प्रोग्रामिंग, लेकिन उत्तरार्द्ध के लिए निराश।

यह कम से कम निर्भरता रखने के लिए अनुकूल होगा:

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

तुच्छ, है ना?

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 

to_s कसौटी में विफल रहता है क्योंकि 1.9 रास्ता Array#to_s काम करता है बदल गया है। संगतता के लिए इसे बदलें:

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

मुझे केक चाहिए।

Btw - यहाँ metaprogramming कोड आकार में कटौती और काफी लचीलापन बढ़ जाएगी:

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

यह Amadan के जवाब से प्रेरित है लेकिन कोड के कम लाइनों का उपयोग करता है:

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