ansaurus

Question

Implement Apect-oriented-like nested around filters with Ruby?

Answer 1

+1 A:

One possibility is to explicitly specify the "before" and "after" part of each filter:

Code

class Foo
  def initialize
    @before_filters = Array.new
    @after_filters = Array.new
  end

  def bar
    @before_filters.each { |f| f.call }
    puts "done"
    @after_filters.each { |f| f.call }
  end

  def add_filters(options)
    @before_filters.insert(0, options[:before])
    @after_filters << options[:after]
  end
end

Usage example

>> foo = Foo.new
>> foo.add_filters(:before => lambda { puts "<body>" },
                   :after => lambda { puts "</body>" })
>> foo.add_filters(:before => lambda { puts "<html>" },
                   :after => lambda { puts "</html>" })
>> foo.bar
<html>
<body>
done
</body>
</html>

Pär Wieslander 2010-06-15 17:26:39

This is actually my current implementation, but unfortunately I have a need whereby the around_filter is a better fit. Thanks, though. :)

Mario 2010-06-15 17:46:36

Answer 2

+1 A:

The yield in your filters will try to yield to the block defined at the point of their definition, which is not what you want. It will work with the explicit block form (in 1.9) as follows:

class Foo
  attr_accessor :around_filter

  def initialize
    #filters which wrap the following one are the ones with interesting logic
    #vanilla do-nothing filter
    @around_filter = Proc.new{|&blk| blk.call }
  end

  def bar
    #would execute the around filters however deeply nested, then "meaty code"
    @around_filter.call do
      #meaty code here
      puts 'done' 
    end
  end

  #I expected to point only to the topmost filter, hoping to recurse
  def add_around_filter(&filter)
    prior_around_filter = @around_filter
    @around_filter = Proc.new do |&blk|
      filter.call do
        prior_around_filter.call(&blk)
      end
    end
  end
end

foo = Foo.new
foo.add_around_filter do |&blk|
  puts 'strawberry'
  blk.call
  puts 'blueberry'
end
foo.add_around_filter do |&blk|
  puts 'orange'
  blk.call
  puts 'grape'
end
foo.bar #=> orange, strawberry, done, blueberry, grape

Marc-André Lafortune 2010-06-15 17:32:02

That little bit of code was quite elusive. A huge thanks, Marc-André! A big help!

Mario 2010-06-15 18:22:45

It's amazing what a big impact the very subtle block semantics changes in Ruby 1.9 have.

Jörg W Mittag 2010-06-15 18:36:21

ansaurus

tags:

views:

answers:

Implement Apect-oriented-like nested around filters with Ruby?

Code

Usage example

related questions