ruby - 如何在 Sinatra 中创建类似 Rails 的前置过滤器？

Question

class Foo
  def do_before
    ...
  end

  def do_something
    ...

有没有办法do_before在类中的其他方法之前运行方法Foo（如do_something）？

似乎 Sinatrabefore块在每个 HTTP 请求之前运行，这与该类无关。

编辑：正如迈克尔在评论中指出的那样，Rails 提供的唯一类似功能是在控制器中。但是，Rails 和 Sinatra 都提供了与此功能类似的功能。

Answer 1

正如iain在评论中指出的那样，您指定的示例并非特定于 Rails/Sinatra。我假设你想要像 Rails 中的过滤器一样，这就是 Sinatra 提供的：

Sinatra 的模块化应用程序：

class Foo < Sinatra::Base

  before do
    "Do something"
  end

  get '/' do
    "Hello World"
  end
end

class Bar < Sinatra::Base

  before do
    "Do something else"
  end

  get '/' do
    "Hello World"
  end
end

在你的config.rb档案中，

require 'foo.rb'
require 'bar.rb'

map '/foo' do
  run Foo
end

map '/bar' do
  run Bar
end

这是最接近 Sinatra 中 Rails 控制器的类比。创建更多这样的类，您将拥有类似的功能（类似，但可能与您在 Rails 世界中所期望的不同）。

Answer 2

您还可以使用一些元编程来创建一个前置过滤器。例如：

class Foo
  def method_1; p "Method 1"; end
  def method_2; p "Method 2"; end
  def preprocess_method; p "Pre-Processing method"; end

  def self.before_filter m
    current_methods = instance_methods(false) - [m]
    self.new.instance_eval do
      current_methods.each do |meth|
        inst_method =  public_method(meth)
        self.class.send :define_method,inst_method.name do
          public_send m
          inst_method.call
        end
      end
    end
  end
  before_filter :preprocess_method
end

o = Foo.new
o.method_1
#output: 
"Pre-Processing method"
"Method 1"

o.method_2
#outputs
"Pre-Processing method"
"Method 2"

在这种情况下，preprocess_method将在每次调用 Foo 类中定义的任何实例方法之前调用（即您的示例中的 do_before）。

Answer 3

不知道你在做什么让你很难知道如何回答，但要增加网络上的信息；）我将提供@fmendez 答案的替代方案：

module Filterable
  def self.included(base)
    base.extend ClassMethods
  end
  module ClassMethods
    def do_before( name, &block )
      before_filters[name.to_sym] = block
    end
    def before_filters
      @before_filters ||= {}
    end
    def method_added( name )
      return if name.to_s.start_with?("unfiltered_")
      return if before_filters.has_key? name
      before_filters[name.to_sym] ||= nil
      alias_method "unfiltered_#{name}", name
      define_method name do |*args,&block|
        self.class.before_filters[name.to_sym].call if self.class.before_filters[name.to_sym]
        send "unfiltered_#{name}", *args, &block
      end
    end
  end
end

class Foo
  include Filterable

  def something( x )
    x * 3
  end

  do_before :something do
    puts "Before…"
  end
end

Foo.new.something 4

输出：

之前…<br> # => 12