Question

我有一个提交的每个文件的diff stats列表（在Git中使用diff --numstat），我需要将其解析为树结构作为哈希，所以我可以将它用作JSON。原始数据的格式如下：

1       1       app/assets/javascripts/foo.js.coffee
2       1       app/assets/javascripts/bar.js
16      25      app/assets/javascripts/baz.js.coffee
11      0       app/controllers/foo_controller.rb
3       2       db/schema.rb
41      1       lib/foobar.rb

我需要将其解析为嵌套的哈希格式，如下所示：

{ name: "app", children: [
  { name: "assets", children: [
    { name: "javascripts", children: [
      { name: "foo.js.coffee", add: 1, del: 1 },
      { name: "bar.js", add: 2, del: 1 }
      { name: "baz.js.coffee", add: 16, del: 25 }
    ], add: 19, del: 27 },
    ...
  ] } 
] }

树的每个级别由其名称表示，子级表示为哈希，以及该树的添加和删除总数。

有没有一种有效的方法在Ruby中构建这样的哈希？

Answer 1

完整来源：https://gist.github.com/dimitko/5541709。您可以下载并直接运行它（只需确保拥有awesome_print gem;它以更加人性化的格式显示对象层次结构。）

我稍微丰富了你的测试输入，以确保算法不会犯愚蠢的错误。

鉴于此输入：

input = <<TEXT
2       1       app/assets/javascripts/bar.js
16      25      app/assets/javascripts/baz.js.coffee
1       1       app/assets/javascripts/foo.js.coffee
4       9       app/controllers/bar_controller.rb
3       2       app/controllers/baz_controller.rb
11      0       app/controllers/foo_controller.rb
3       2       db/schema.rb
41      1       lib/foobar.rb
12      7       lib/tasks/cache.rake
5       13      lib/tasks/import.rake
TEXT

这个预期结果：

[{:name=>"app", :add=>37, :del=>38, :children=>[{:name=>"assets", :add=>19, :del=>27, :children=>[{:name=>"javascripts", :add=>19, :del=>27, :children=>[{:name=>"bar.js", :add=>2, :del=>1}, {:name=>"baz.js.coffee", :add=>16, :del=>25}, {:name=>"foo.js.coffee", :add=>1, :del=>1}]}]}, {:name=>"controllers", :add=>18, :del=>11, :children=>[{:name=>"bar_controller.rb", :add=>4, :del=>9}, {:name=>"baz_controller.rb", :add=>3, :del=>2}, {:name=>"foo_controller.rb", :add=>11, :del=>0}]}]}, {:add=>3, :del=>2, :name=>"db", :children=>[{:name=>"schema.rb", :add=>3, :del=>2}]}, {:add=>58, :del=>21, :name=>"lib", :children=>[{:name=>"foobar.rb", :add=>41, :del=>1}, {:name=>"tasks", :add=>17, :del=>20, :children=>[{:name=>"cache.rake", :add=>12, :del=>7}, {:name=>"import.rake", :add=>5, :del=>13}]}]}]

这段代码：

def git_diffnum_parse_paths(list, depth, out)
  to = 1
  base = list.first[:name][depth]
  while list[to] and list[to][:name][depth] == base do
    to += 1
  end

  if list.first[:name][depth+1]
    out << {name: base, add: 0, del: 0, children: []}

    # Common directory found for the first N records; recurse deeper.
    git_diffnum_parse_paths(list[0..to-1], depth + 1, out.last[:children])

    add = del = 0
    out.last[:children].each do |x| add += x[:add].to_i; del += x[:del].to_i; end
    out.last[:add] = add
    out.last[:del] = del
  else
    # It's a file, we can't go any deeper.
    out << {name: list.first[:name].last, add: list.first[:add].to_i, del:     list.first[:del].to_i}
  end

  if list[to]
    # Recurse in to try find common directories for the deeper records.
    git_diffnum_parse_paths(list[to..-1], depth, out)
  end

  nil
end

def to_git_diffnum_tree(txt)
  items = []
  txt.split("\n").each do |line|
    m = line.match(/(\d+)\s+(\d+)\s+(.+)/).to_a[1..3]
    items << {add: m[0], del: m[1], name: m[2]}
  end

  items.sort! { |a,b|
    a[:name] <=> b[:name]
  }

  items.each do |item|
    item[:name] = item[:name].split("/")
  end

  out = []
  git_diffnum_parse_paths(items, 0, out)
  out
end

这段代码正在使用它：

require 'awesome_print'
out = to_git_diffnum_tree(input)
puts; ap out; puts
puts; puts "Expected result:"; puts expected.inspect
puts; puts "Actual result: ";  puts out.inspect
puts; puts "Are expected and actual results identical: #{expected == out}"

它似乎产生了你想要的东西。

注意：

我按目录/文件名对解析的条目数组进行排序。这样做是为了避免遍历整个列表以搜索公共目录;相反，算法可以扫描列表直到第一次不匹配。
我认为这不是最优化的解决方案，但这是我在一小时内想出来的。
我已经在要点中留下了一些[un-]注释puts语句，以防你想要大致了解算法是如何工作的。
如果你想给它一个更坚实的测试，试试这样的事情：

git diff --numstat`git rev-list --max-parents = 0 HEAD | head -n 1` HEAD

这可以为您提供自初始提交以来的添加和删除次数（假设您的Git版本为> = 1.7.4.2），这是一个更大的输入，您可以为算法提供更严格的测试。< / p>

希望我帮助过。

Answer 2

定义“高效”。如果您的问题是“性能”，那么您的解决方案就不是红宝石。

除非你真的在Linux源代码上运行这个脚本，否则我不会担心性能，只是意图清晰。

我从@ dimitko的解决方案中获取灵感，并最小化了所使用的代码。

https://gist.github.com/x1024/3d0f9ad61fcb4b189be3

def git_group lines, root = 'root'
  if lines.count == 1 and lines[0][:name].empty? then
    return {
      name: root,
      add: lines.map { |l| l[:add] }.reduce(0, :+),
      del: lines.map { |l| l[:del] }.reduce(0, :+),
    }
  end

  lines = lines.group_by { |line| line[:name].shift }
               .map { |key, value| git_group(value, key) }

  return {
    name: root,
    add: lines.map { |l| l[:add] }.reduce(0, :+),
    del: lines.map { |l| l[:del] }.reduce(0, :+),
    children: lines
  }
end

def to_git_diffnum_tree(txt)
  data = txt.split("\n")
    .map { |line| line.split() }
    .map { |line| {add: line[0].to_i, del: line[1].to_i, name: line[2].split('/')} }
    .sort_by { |item| item[:name] }

  git_group(data)[:children]
end

如果您愿意与您的数据格式妥协（即返回相同的数据但采用不同的结构），您可以使用更少的代码执行此操作：

https://gist.github.com/x1024/5ecfdfe886e31f8b5ab9

def git_group lines
  dirs = lines.select { |line| line[:name].count > 1 }
  files = (lines - dirs).map! { |file| [file.delete(:name).shift, file] }
  dirs_processed = dirs.group_by { |dir| dir[:name].shift }
                    .map { |key, value| [key, git_group(value)] }
  data = dirs_processed.concat(files)

  return {
    add: data.map { |k,l| l[:add] }.reduce(0, :+),
    del: data.map { |k,l| l[:del] }.reduce(0, :+),
    children: Hash[data]
  }
end

def to_git_diffnum_tree(txt)
  data = txt.split("\n")
    .map { |line| line.split() }
    .map { |line| {add: line[0].to_i, del: line[1].to_i, name: line[2].split('/')} }
    .sort_by { |item| item[:name] }

  git_group(data)[:children]
end

记住孩子们，在Ruby中编写C ++是不好的。

使用嵌套哈希有效地构建文件系统树结构

2 个答案: