Question

我有一个格式为yaml的文件：

parameters:
  - param_name: age
    requires:
    - name
  - param_name: height
    requires:
    - name

基于这种格式，我想接受键和值的散列，并确定键和值的组合是否有效。例如，基于以上示例，如果有人提交了具有值的散列：

{'age' => 15, 'height' => '6ft'}

因为参数名称是必需的，所以它将被视为无效。所以有效的提交看起来像

{'age' => 15, 'height' => '6ft', 'name' => 'Abe Lincoln'}.

基本上我想要的是这个：

对于每个参数对象，如果它下面有一个requires数组。检查该数组中元素的所有参数param_names，如果有缺少exit。

我有一个非常丑陋的双循环检查这个但我想收紧代码。我想我可以使用块来验证我需要的数据。这是我到目前为止所提出的：

require 'yaml'
requirements = YAML.load_file('./require.yaml')
require_fields = Array.new

requirements['parameters'].each do |param|
  require_fields.concat(param['require']) if param.has_key? 'require'
end

require_fields.each do |requirement|
  found = false
  requirements['parameters'].each do |param|
    if param['param_name'] == requirement
      found = true
    end
  end
  abort "#{requirement} is a required field" unless found
end

Answer 1

如果你把它变成更惯用的Ruby，你可以把它清理干净：

require 'yaml'
requirements = YAML.load_file('./require.yaml')

require_fields = requirements['parameters'].select do |param|
  param.has_key?('require')
end.map do |param|
  param['require']
end

require_fields.each do |requirement|
  found = requirements['parameters'].any? do |param|
    param['param_name'] == requirement
  end

  abort "#{requirement} is a required field" unless found
end

你也可以这样做：

require_fields = requirements['parameters'].map do |param|
  param['require']
end.compact

只要您的require是某种内容或nil，这可能就足够了。

您还可以将输入YAML转换为依赖项的简单哈希结构：

dependencies = requirements.map do ||
  [ param['param_name'], param['requires'] ]
end.to_h

然后你可以很容易地测试：

dependencies.each do |name, requirements|
  found = requirements.find do |required_name|
    !dependencies[required_name]
  end

  abort "#{found} is a required field" unless found
end

这是对代码的粗略修改，但我希望它能为您提供一些想法。

Answer 2

我会随后进行检查，收集错误并立即报告：

req = YAML.load 'parameters:
  - param_name: age
    requires:
    - name
  - param_name: height
    requires:
    - name'
input = {'age' => 15, 'height' => '6ft'}

req['parameters'].each_with_object([]) do |req, err|
  next unless input[req['param_name']] # nothing to check
  missed = req['requires'].reject { |param| input[param] }
  errors = missed.map do |param|
    [req['param_name'], param].join(' requires ')
  end
  err.concat(errors)
end
#⇒ ["age requires name", "height requires name"]

或者，链接：

req['parameters'].each_with_object(Hash.new { |h, k| h[k] = [] }) do |req, err|
  next unless input[req['param_name']] # nothing to check

  req['requires'].each do |param|
    err[param] << req['param_name'] unless input[param]
  end
end.map do |missing, required|
  "Missing #{missing} parameter, required for: [#{required.join(', ')}]"
end.join(',')
#⇒ "Missing name parameter, required for: [age, height]"

Ruby数组哈希解析

2 个答案: