处理铁路中 STI 子类路线的最佳实践

Question

我的 Rails 视图和控制器中充斥着 redirect_to、link_to 和 form_for 方法调用。有时 link_to 和 redirect_to 在它们链接的路径中是明确的（例如 link_to 'New Person', new_person_path），但很多时候这些路径是隐式的（例如link_to 'Show', person）。

我向模型添加了一些单表继承 (STI)（例如 Employee ），并且所有这些方法都会因子类的实例而中断（例如 Employee） ;当 Rails 执行 link_to @person 时，会出现 undefined method employee_path' for #<#:0x0000010226d038> 错误。 Rails 正在寻找由对象的类名（employee）定义的路由。这些员工路线未定义，并且没有员工控制器，因此操作也未定义。

这个问题之前已经被问过：

1. 在StackOverflow，答案是编辑整个代码库中 link_to 等的每个实例，并
2. 在 StackOverflow 再次，有两个人建议使用 routes.rb 将子类资源映射到父类 (map.resources :employees, :controller = >“人”）。同一个 SO 问题中的最佳答案建议使用 .becomes 对代码库中的每个实例对象进行类型转换，
3. 而另一个位于 StackOverflow，最上面的答案是 Do Repeat Yourself 阵营的方式，并建议为每个子类创建重复的脚手架。
4. 这里再次出现同样的问题，其中最重要的答案似乎是错误的（Rails magic有效！）
5. 在网络的其他地方，我找到了这篇博文 其中F2Andy建议在代码中各处的路径中进行编辑。
6. 在博客文章单表继承和 RESTful 路由 在逻辑现实设计中，建议将子类的资源映射到超类控制器，如上面的答案 2 所示。
7. Alex Reisner 有一篇文章 Rails 中的单表继承，其中他主张不要在 routes.rb 中将子类的资源映射到父类，因为这只能捕获来自 link_to 和 redirect_to 的路由中断，但不是来自 form_for。因此他建议向父类添加一个方法，让子类对它们的类​​撒谎。听起来不错，但他的方法给了我错误未定义的局部变量或方法`child' for #。

因此，看起来最优雅且最具共识的答案（但并不完全那么优雅，也太多共识），是将资源添加到您的路线.rb。但这对于 form_for 不起作用。我需要一些澄清！为了提炼上面的选择，我的选择是

1. routes.rb 中超类的控制器（并希望我不需要在任何子类上调用 form_for）
2. 将子类的资源映射到 使类相互欺骗的方法
3. 编辑代码中隐式或显式调用对象操作路径的每个实例，更改路径或对对象进行类型转换。

面对所有这些相互矛盾的答案，我需要做出裁决。在我看来，似乎没有好的答案。这是 Rails 设计的失败吗？如果是这样，这是一个可以修复的错误吗？或者如果没有，那么我希望有人可以直接告诉我这个问题，引导我了解每个选项的优点和缺点（或解释为什么这不是一个选项），以及哪个是正确的答案，以及为什么。或者我在网上找不到正确的答案？

Answer 1

这是我能想到的最简单的解决方案，副作用最小。

class Person < Contact
  def self.model_name
    Contact.model_name
  end
end

现在，url_for @person 将按预期映射到 contact_path。

工作原理：URL 帮助程序依赖 YourModel.model_name 来反映模型并生成（其中包括）单数/复数路由键。这里Person基本上是在说我就像Contact老兄，问他。

Answer 2

我也有同样的问题。使用 STI 后，form_for 方法发布到错误的子 URL。

NoMethodError (undefined method `building_url' for

我最终为子类添加了额外的路由，并将它们指向相同的控制器

 resources :structures
 resources :buildings, :controller => 'structures'
 resources :bridges, :controller => 'structures'

另外：

<% form_for(@structure, :as => :structure) do |f| %>

在这种情况下，结构实际上是一个建筑物（子类），

在使用 form_for.

Answer 3

我建议你看一下：https://stackoverflow.com/a/605172/445908，使用此方法将使您能够使用“form_for”。

ActiveRecord::Base#becomes

Answer 4

我也遇到了这个问题，并在与我们类似的问题上得到了这个答案。这对我有用。

form_for @list.becomes(List)

此处显示的答案：使用具有相同控制器的 STI 路径

.becomes 方法被定义为主要用于解决 STI 问题，例如您的 form_for 问题。

.becomes 信息位于：http://apidock.com/rails/ActiveRecord /Base/becomes

回复超级晚，但这是我能找到的最好答案，而且对我来说效果很好。希望这对某人有所帮助。干杯!

Answer 5

在路线中使用类型：

resources :employee, controller: 'person', type: 'Employee' 

http://samurails.com/tutorial/single-table-inheritance-with-rails-4-part-2/

Answer 6

遵循@Prathan Thananart 的想法，但尽量不破坏任何东西。 （因为涉及太多魔法）

class Person < Contact
  model_name.class_eval do
    def route_key
     "contacts"
    end
    def singular_route_key
      superclass.model_name.singular_route_key
    end
  end
end

现在 url_for @person 将按预期映射到 contact_path。

Answer 7

好吧，我在 Rails 的这个领域遇到了很多挫折，并得出了以下方法，也许这会对其他人有所帮助。

首先请注意，网上和网上的许多解决方案建议对客户端提供的参数使用常量化。这是一种已知的 DoS 攻击媒介，因为 Ruby 不会对符号进行垃圾收集，从而允许攻击者创建任意符号并消耗可用内存。

我已经实现了下面的方法，该方法支持模型子类的实例化，并且对于上面的 contantize 问题是安全的。它与 Rails 4 的做法非常相似，但也允许多级子类化（与 Rails 4 不同），并且可以在 Rails 3 中使用。

# initializers/acts_as_castable.rb
module ActsAsCastable
  extend ActiveSupport::Concern

  module ClassMethods

    def new_with_cast(*args, &block)
      if (attrs = args.first).is_a?(Hash)
        if klass = descendant_class_from_attrs(attrs)
          return klass.new(*args, &block)
        end
      end
      new_without_cast(*args, &block)
    end

    def descendant_class_from_attrs(attrs)
      subclass_name = attrs.with_indifferent_access[inheritance_column]
      return nil if subclass_name.blank? || subclass_name == self.name
      unless subclass = descendants.detect { |sub| sub.name == subclass_name }
        raise ActiveRecord::SubclassNotFound.new("Invalid single-table inheritance type: #{subclass_name} is not a subclass of #{name}")
      end
      subclass
    end

    def acts_as_castable
      class << self
        alias_method_chain :new, :cast
      end
    end
  end
end

ActiveRecord::Base.send(:include, ActsAsCastable)

在尝试了各种与上面建议的类似的“开发中的子类加载问题”方法之后，我发现唯一可靠的方法是在我的模型类中使用“require_dependency”。这确保了类加载在开发中正常工作并且不会在生产中引起问题。在开发过程中，如果没有“require_dependency”，AR 将无法了解所有子类，这会影响为匹配类型列而发出的 SQL。此外，如果没有“require_dependency”，您也可能会遇到同时拥有多个版本的模型类的情况！ （例如，当您更改基类或中间类时，可能会发生这种情况，子类似乎并不总是重新加载，并且是旧类的子类）

# contact.rb
class Contact < ActiveRecord::Base
  acts_as_castable
end

require_dependency 'person'
require_dependency 'organisation'

我也不会按照上面的建议覆盖 model_name 因为我使用 I18n 和不同子类的属性需要不同的字符串，例如：tax_identifier 成为组织的“ABN”，个人的“TFN”（在澳大利亚）。

我还使用路由映射，如上所述，设置类型：

resources :person, :controller => 'contacts', :defaults => { 'contact' => { 'type' => Person.sti_name } }
resources :organisation, :controller => 'contacts', :defaults => { 'contact' => { 'type' => Organisation.sti_name } }

除了路由映射之外，我还使用 InheritedResources 和 SimpleForm，并使用以下通用表单包装器进行新操作：

simple_form_for resource, as: resource_request_name, url: collection_url,
      html: { class: controller_name, multipart: true }

编辑操作：

simple_form_for resource, as: resource_request_name, url: resource_url,
      html: { class: controller_name, multipart: true }

...和 为了使这项工作有效，在我的基础 ResourceContoller 中，我将 InheritedResource 的 resource_request_name 公开为视图的辅助方法：

helper_method :resource_request_name 

如果您不使用 InheritedResources，则在“ResourceController”中使用类似以下内容：

# controllers/resource_controller.rb
class ResourceController < ApplicationController

protected
  helper_method :resource
  helper_method :resource_url
  helper_method :collection_url
  helper_method :resource_request_name

  def resource
    @model
  end

  def resource_url
    polymorphic_path(@model)
  end

  def collection_url
    polymorphic_path(Model)
  end

  def resource_request_name
    ActiveModel::Naming.param_key(Model)
  end
end

总是很高兴听到其他人的经验和改进。

Answer 8

我最近记录了我的尝试在 Rails 3.0 应用程序中获得稳定的 STI 模式。这是 TL;DR 版本：

# app/controllers/kase_controller.rb
class KasesController < ApplicationController

  def new
    setup_sti_model
    # ...
  end

  def create
    setup_sti_model
    # ...
  end

private

  def setup_sti_model
    # This lets us set the "type" attribute from forms and querystrings
    model = nil
    if !params[:kase].blank? and !params[:kase][:type].blank?
      model = params[:kase].delete(:type).constantize.to_s
    end
    @kase = Kase.new(params[:kase])
    @kase.type = model
  end
end

# app/models/kase.rb
class Kase < ActiveRecord::Base
  # This solves the `undefined method alpha_kase_path` errors
  def self.inherited(child)
    child.instance_eval do
      def model_name
        Kase.model_name
      end
    end
    super
  end  
end

# app/models/alpha_kase.rb
# Splitting out the subclasses into separate files solves
# the `uninitialize constant AlphaKase` errors
class AlphaKase < Kase; end

# app/models/beta_kase.rb
class BetaKase < Kase; end

# config/initializers/preload_sti_models.rb
if Rails.env.development?
  # This ensures that `Kase.subclasses` is populated correctly
  %w[kase alpha_kase beta_kase].each do |c|
    require_dependency File.join("app","models","#{c}.rb")
  end
end

此方法解决了您列出的问题以及其他人在使用 STI 方法时遇到的许多其他问题。

Answer 9

我发现的最干净的解决方案是将以下内容添加到基类中：

def self.inherited(subclass)
  super

  def subclass.model_name
    super.tap do |name|
      route_key = base_class.name.underscore
      name.instance_variable_set(:@singular_route_key, route_key)
      name.instance_variable_set(:@route_key, route_key.pluralize)
    end
  end
end

它适用于所有子类，并且比覆盖整个模型名称对象安全得多。通过仅针对路由键，我们可以解决路由问题，而不会破坏 I18n 或因覆盖 Rails 定义的模型名称而导致任何潜在副作用的风险。

Answer 10

如果你没有嵌套路由，你可以尝试这个：

resources :employee, path: :person, controller: :person

或者你可以采取另一种方式并使用一些 OOP 魔法，如下所述： https://coderwall.com/p/yijmuq

在第二种方式中，您可以为所有嵌套模型制作类似的助手。

Answer 11

这是一种安全、干净的方法，可以让它在我们使用的表单和整个应用程序中工作。

resources :districts
resources :district_counties, controller: 'districts', type: 'County'
resources :district_cities, controller: 'districts', type: 'City'

然后我就有了我的形式。为此添加的部分是 as: :district。

= form_for(@district, as: :district, html: { class: "form-horizontal",         role: "form" }) do |f|

希望这有帮助。

Answer 12

覆盖 model_name 似乎很危险。使用 .becomes 似乎是更安全的选择。

一个问题是您不知道正在处理的模型（以及基本模型）的情况。

我只是想分享一下，在这种情况下，可以使用：

foo.becomes(foo.class.base_class)

为了便于使用，我已将此方法添加到我的 ApplicationRecord 中：

def becomes_base
  becomes(self.class.base_class)
end

将 .becomes_base 添加到一些路由辅助方法对我来说似乎没什么大不了的。

Answer 13

按照 @prathan-thananart answer，对于多个 STI 类，您可以将以下内容添加到父模型 ->

class Contact < ActiveRecord::Base
  def self.model_name
    ActiveModel::Name.new(self, nil, 'Contact')
  end
end

这将使包含联系人数据的每个表单以 params[:contact] 形式发送参数，而不是 params[:contact_person]、params[:contact_whatever]。

Answer 14

如果我考虑像这样的 STI 继承：

class AModel < ActiveRecord::Base ; end
class BModel < AModel ; end
class CModel < AModel ; end
class DModel < AModel ; end
class EModel < AModel ; end

在“app/models/a_model.rb”中添加：

module ManagedAtAModelLevel
  def model_name
    AModel.model_name
  end
end

然后在 AModel 类中：

class AModel < ActiveRecord::Base
  def self.instanciate_STI
    managed_deps = { 
      :b_model => true,
      :c_model => true,
      :d_model => true,
      :e_model => true
    }
    managed_deps.each do |dep, managed|
      require_dependency dep.to_s
      klass = dep.to_s.camelize.constantize
      # Inject behavior to be managed at AModel level for classes I chose
      klass.send(:extend, ManagedAtAModelLevel) if managed
    end
  end

  instanciate_STI
end

因此我什至可以轻松选择我想要使用默认模型的模型，而无需触摸子类定义。非常干燥。

Answer 15

这种方法对我来说没问题（在基类中定义这个方法）：

def self.inherited(child)
  child.instance_eval do
    alias :original_model_name :model_name
    def model_name
      Task::Base.model_name
    end
  end
  super
end

Answer 16

您可以创建返回虚拟父对象的方法以用于路由目的

class Person < ActiveRecord::Base      
  def routing_object
    Person.new(id: id)
  end
end

，然后只需调用 form_for @employee.routing_object
如果没有类型，将返回 Person 类对象

Answer 17

我赞成使用 PolymorphicRoutes 或 url_for 根据资源、任何命名空间等动态生成路由。

https://api.rubyonrails.org/classes/ActionDispatch/Routing/PolymorphicRoutes.html

https://api.rubyonrails.org/classes/ActionDispatch/Routing/UrlFor.html

polymorphic_url([:admin, @article, @comment])
# => admin_article_comment_url(@article, @comment)

edit_polymorphic_path(@post) 
# => "/posts/1/edit"

与 <代码>管理命名空间

url_for([:admin, Role])
# => "admin/roles" # index

url_for([:admin, Role, action: :new])
# => "admin/roles/new" # new

url_for([:admin, @role])
# => "admin/roles/1" # show; for destroy, use link "method: :delete"

url_for([:edit, :admin, @role])
# => "admin/roles/1/edit" # edit

Answer 18

hackish，但这只是解决方案列表中的另一个。

class Parent < ActiveRecord::Base; end

Class Child < Parent
  def class
    Parent
  end
end

适用于 Rails 2.x 和 3.x