6

这个问题的一个更长的替代措辞是：“有哪些 Ruby 库或方法可以测试任意数据结构（散列、数组、整数、浮点数、字符串等）的形状？”

首先，让我举一个简单的例子：

hash_1 = {
  k1: 1.0,
  k2: 42,
  k3: {
    k4: "100.00",
    k5: "dollars"
  }
}

接下来，我想验证它——我的意思是与形状/模式/模板进行比较，例如：

shape_a = {
  k1: Float,
  k2: Integer,
  k3: Hash
}

或者，也许，更具体的形状：

shape_b = {
  k1: Float,
  k2: Integer,
  k3: {
    k4: String,
    k5: String
  }
}

一种可能的 API 可能如下所示：

require '_____________'

hash_1.schema = shape_a
hash_1.valid? # => true

hash_1.schema = shape_b
hash_1.valid? # => true

这些只是示例，我对其他方法持开放态度。

大约 3 年前，我写了schema_hash来挠痒痒。我计划更新它，但首先我想了解替代方案和更好的方法。

这个问题的动机来自一个 Mongo 用例，但这个问题不一定是 Mongo 特定的。

就像我在顶部提到的那样，我希望看到或构建验证任意数据结构的能力：散列、数组、原语等，在任何嵌套组合中。

“你不需要 Mongo 的模式，那你为什么在乎呢？”

  • 就像我上面提到的，我不仅仅考虑 Mongo 用例
  • 但是即使在 Mongo 的上下文中，即使您不想要求数据结构具有某种形状，根据形状或模式测试数据结构并采取相应的行动仍然很有用。

“为什么不写自定义验证？”

当我从事以前的项目时，这正是我开始的地方。为嵌套哈希重复编写验证是很痛苦的。我开始思考什么会使它变得更容易，我想出了一个类似于我上面分享的语法。

外面有什么？我应该尝试什么？

综上所述，我很好奇其他人在做什么。有没有“黄金之路”？我正在尝试不同的方法，例如嵌入文档和与Mongoid 关联的 validates_related ......但是当哈希嵌套超过一个级别或这么深时，这些方法似乎有点矫枉过正。

我四处寻找Ruby Toolbox 上的 Validation 以进行验证（双关语），但没有找到我想要的东西。当我在那里时，我建议了一个名为“验证”的新类别。

我所要求的内容很可能不太适合“验证”主题领域，而更适合其他领域，例如“数据结构”和“遍历”。如果是这样，请指出我正确的方向。

4

7 回答 7

7

编辑：重读你的问题，我的回答似乎有点过于简单。我将把它留给你，我是否应该删除它，只需通过评论让我知道。

一个非常简单的方法是：

class Hash
  def has_shape?(shape)
    all? { |k, v| shape[k] === v }
  end
end

像这样使用：

hash_1.has_shape?(shape_a) #=> true
shape_b = { k1: Float, k2: Integer, k3: Integer }
hash_1.has_shape?(shape_b) #=> false

这似乎已经很好地照顾了您描述的第一个版本。将其分解到 lib 中并不难，因此它不会 monkey-patch Hash。向该方法添加递归has_shape?将处理您更复杂的情况。

更新：这是一个带有递归的版本：

class Hash
  def has_shape?(shape)
    all? do |k, v|
      Hash === v ? v.has_shape?(shape[k]) : shape[k] === v
    end
  end
end
于 2012-06-19T18:51:23.740 回答
2

这可能是您正在寻找的：

https://github.com/JamesBrooks/hash_validator

于 2013-04-15T07:01:41.287 回答
2

如果您正在使用 Rails 并且只想验证密钥，您可以使用assert_valid_keys：

{ name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
{ name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
{ name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing

https://apidock.com/rails/Hash/assert_valid_keys

于 2017-04-14T01:14:19.507 回答
1

我写了一个 gem 来验证哈希之类的数据http://rubygems.org/gems/validates_simple并且很容易添加验证来检查值是否是类的成员。至于验证嵌套值，如果需要，我将不得不更新 gem 以支持这一点。添加规则很简单

  module Validation
    module Rules
      def validates_is_a_member_of(field, class, message='')
         callback = lambda do |data|
           data[field].is_a? Class
         end
         validates(field, callback, message)
      end
    end
  end

之后，您可以执行 validator.validates_is_a_member_of('age', Integer, 'age must be an int') 并执行 validator.validate({'age': 232423})

于 2013-12-31T19:12:27.457 回答
1

似乎Schemacop非常适合这种场合。

于 2019-08-03T17:28:19.227 回答
1

这是对 Michael Kohl 的递归 has_shape 的一个小调整？适用于 shape_a 和 shape_b 的方法（添加了一个测试以检查形状是否具有要递归的子哈希）：

  def has_shape?(shape)
    all? do |k, v|
      (Hash === v && Hash === shape[k]) ? v.has_shape?(shape[k]) : shape[k] === v
    end
  end

另外，FWIW 我发现 is_a? 比 === 更具可读性。例如：

  def has_shape?(shape)
    all? do |k, v|
      (v.is_a?(Hash) && shape[k].is_a?(Hash)) ? v.has_shape?(shape[k]) : v.is_a?(shape[k])
    end
  end

但是，如果您的形状与 JSON 兼容，那么您可能需要考虑Ruby JSON Schema Validator。它更重量级和更冗长，但您可以使用它来验证散列以及 JSON，它为您提供更多控制权（例如，必需键、可选键等）。

于 2020-01-28T02:53:03.500 回答
0

这是一个使用表达式列表的版本：

class Hash
  def has_shape?(shape)
    all? do |key, value|
      if value.is_a? Hash
        value.has_shape?(shape[key])
      else
        shape[key].all? { |expression| expression.call(value) }
      end
    end
  end
end

用法：

shape = {
  type: [
    -> (type) { type.is_a? String },
    -> (type) { !type.blank?  },
    -> (type) { %(text number).include? type }
  ]
}

{ type: "text" }.has_shape? shape # => true

有了这个，您应该能够非常动态地确保哈希的形状。

更新：

使用此版本，您无法检查是否缺少键/值对，因为我们正在询问所有内容？从我们正在调用该方法的哈希中。这结果呢？仅迭代该哈希上存在的键/值。

我已经更新了实现以尊重“目标”哈希进行比较。现在has_shape？方法成功确定丢失的键/值对。

class Hash
  def has_shape?(shape)
    shape.all? do |key, _|
      if self[key.to_s].is_a? Hash
        self[key.to_s].has_shape?(shape[key])
      else
        shape[key].all? { |expression| expression.call(self[key.to_s]) }
      end
    end
  end
end
于 2020-05-04T12:46:55.410 回答