在 Rails 中对非粗路由进行验证的干净方法？

Question

您如何在 NON-CRUD 路线上实施验证？ 例如，有一条用于浏览recipes的路线。 它接受参数term （用于搜索）、 sort 、 page等。

在 Rails 中执行此操作的最简洁方法是什么？

最直接的解决方案是使用 controller 中的一堆if-else表达式来验证所有这些东西，但我正在寻找更干净、更容易扩展和维护的东西。

我结束了以下

class RequestValidation
  attr_reader :validators
  attr_reader :errors

  def initialize
    @validators = []
    @errors = []
  end

  def add_validator(validator)
    @validators << validator
  end

  def validate
    @validators.each do |validator|
      validator.validate
      @errors += validator.errors
    end
  end

  def valid?
    validate
    errors.empty?
  end

end

验证器示例 class

  class SortValidator < Validator

    VALID_SORT_FIELD = [:created_at, :rate, :total_time]
    VALID_SORT_DIRECTIONS = [:asc, :desc]

    def validate
      return unless param

      valid = true
      begin
        sort = param.to_unsafe_h

        if sort.size == 1
          k = sort.keys[0].to_sym
          v = sort.values[0].to_sym
          valid = VALID_SORT_FIELD.include?(k) && VALID_SORT_DIRECTIONS.include?(v)
        else
          valid = false
        end
      rescue => ex
        valid = false
      end

      @errors << "Sort parameter invalid" unless valid
    end

    def is_valid?
      !errors.empty?
    end
  end

因此， RequestValidation就像所有验证器的构建器/容器 class。 然后，在 controller 中：

    validation = RequestValidation.new
    validation.add_validator(RecipesValidators::SortValidator.new(params[:sort]))

    validation.validate

    if validation.errors.empty?

这样，当需要新的验证时，我们只需要创建一个新的验证器 class 并将其添加到请求验证中。

鉴于我在 Rails 中停顿了几年，有人怀疑这段代码是否干净整洁，是否符合 Ruby 原则。

或者，还有更好的方法？

提前致谢

Answer 1

现在我会 go 在 controller 和数据库之间放置一些合同和强类型结构。

就像是：

# obtain an instance of RecipeSearchParamsContract
def contract
  @contract ||= SomeValidationContract.new
end

# obtain an instance of a coercing struct
def input
  MyStruct.new(params)
end

def query
  MyQuery.new
end

def your_action
  if contract.call(params).success?
    render query.call(input)
  end
end

所以你完全分离了所有的关注点。 可以作为代码基础的好的库是dry-validator和dry-struct ，您可以通过以下方式生成合约：

class SearchParamsContract < Dry::Validation::Contract
  params do
    optional(:sort).hash(max_size?: 1) do
      optional(:rate).value(included_in?: %w[asc desc])
      optional(:created_at).value(included_in?: %w[asc desc])
      optional(:total_time).value(included_in?: %w[asc desc])
    end
    optional(:page).value(:integer)
    optional(:term).filled(:string)
  end
end

使用它，强制和验证的结构在结果本身中可用，因此您可以将所有内容链接在一起并使用结构模式匹配来获得很棒且非常 ruby 代码（没有 rails 额外的东西）

def search
  case contract.call(params)
  in Success(input)
    @recipes = query.call(input)
  else
    render :error
  end
end 

Answer 2

这里的解决方案从来都不是真正的自定义验证器 - 相反，您应该创建一个 class 例如 model 或形成 object 来封装验证和数据。 仅仅因为您的操作不保留任何内容并不意味着您不能使用 model 来表示数据和业务逻辑。

class RecipeSearch
  include ActiveModel::Model
  include ActiveModel::Attributes

  attribute :query, :string
  attribute :sort_by, :string
  # ...

  validates :query, length: { minimum: 5 }
  validates :sort_by, in: ['newest', 'quickest', 'cheapest'] 
  # ...

  # @todo apply filters to Recipe and return collection
  def perform
     # ... 
  end
end

这使您可以添加验证和逻辑。 并将其传递给 forms：

<%= form_with(model: local_assigns(:recipe_seach) || RecipeSearch.new) do |f| %>
  # ...
<% end %>

这也是一种误解，即搜索不能成为 CRUD 的一部分。 毕竟只是阅读应用了过滤器。 如果您确实需要与普通索引分开的视图，那么请务必创建一个单独的搜索操作，但这并不是真正的必需品。

class RecipesController
  def index
    @recipe_search = RecipeSearch.new(search_params)
    @recipes = @recipe_search.perform
  end

  private 

  def search_params
    params.fetch(:recipe_search, {})
          .permit(:query, :sort_by)
  end
end