track which file path things came from

loader.rb

@@ -9,8 +9,8 @@
 require 'pp'
 
 
-def thing(parent, type, name, extra = {})
-  it = {:type => type, :name => name, :fqn => name}.merge(extra)
+def thing(parent, type, name, path, extra = {})
+  it = {:type => type, :name => name, :fqn => name, :path => path}.merge(extra)
   if parent[:type] != nil
     it.merge!({:parent => parent,
                :fqn => "#{parent[:fqn]}::#{name}"})
@@ -65,7 +65,7 @@ def load_dir(playbook_dir)
 
   def mk_role(dict, roles_path, name)
     role_path = File.join(roles_path, name)
-    role = thing(dict, :role, name)
+    role = thing(dict, :role, name, role_path)
 
     # Get the names of roles which support this one with EG vars
     begin
@@ -93,7 +93,7 @@ def mk_role(dict, roles_path, name)
       # FIXME: handle templates in subdirectories of templates/
       next unless File.file? dirent
       data = File.readlines(dirent)
-      thing(role, :template, name, {:data => data})
+      thing(role, :template, name, dirent, {:data => data})
     }
 
     role
@@ -103,6 +103,6 @@ def load_thing(parent, type, dir, file)
     name = File.basename(file, '.*')
     path = File.join(dir, file)
     data = Loader.yaml_slurp(path) || {}
-    thing(parent, type, name, {:data => data})
+    thing(parent, type, name, path, {:data => data})
   end
 end

postprocessor.rb

@@ -33,7 +33,7 @@ def process_vars(dict, varfile)
       if key =~ /(_default|_updates)$/
         []
       else
-        [thing(varfile, :var, key, {:defined => true, :data => value})]
+        [thing(varfile, :var, key, varfile[:path], {:defined => true, :data => value})]
       end
     }
   end
@@ -113,7 +113,7 @@ def process_task(dict, task)
         [i.split("=")[0]]
       end
     }.map {|n|
-      thing(task, :var, n, {:defined => true})
+      thing(task, :var, n, task[:path], {:defined => true})
     }
 
     task[:used_templates] = data.flat_map {|subtask|

resolver.rb

@@ -117,7 +117,7 @@ def resolve_task_include_vars(dict, task)
 
   def resolve_args(dict, task)
     task[:args] = task[:args].uniq.map {|arg|
-      thing(task, :var, arg, {:defined => true})
+      thing(task, :var, arg, task[:path], {:defined => true})
     }
   end
 

scoper.rb

@@ -158,7 +158,7 @@ def check_used_vars_for_task(dict, task)
     task[:used_vars].each {|use|
       var = scope_by_name[use]
       if var == nil
-        var = thing(task, :var, use, {:defined => false})
+        var = thing(task, :var, use, task[:path], {:defined => false})
       end
       var[:used] ||= []
       var[:used].push task

test-grapher.rb

@@ -24,23 +24,24 @@ def test_full
 
   def test_add_node
     d = {}
-    role = thing(d, :role, "role")
-    var = thing(role, :var, "var")
+    role = thing(d, :role, "role", "rolepath")
+    var = thing(role, :var, "var", "varpath")
     Grapher.new.add_node(@g, var)
     assert_equal 1, @g.nodes.length
     @g.nodes.each {|n| assert_equal "role::var", n[:label] }
   end
 
   def test_add_nodes
     d = {}
-    role = thing(d, :role, "rrr")
-    task = thing(role, :task, "ttt")
-    thing(task, :var, "fff")  # fact
-    varfile = thing(role, :varfile, "sss")
-    var = thing(varfile, :var, "vvv")
+    role = thing(d, :role, "rrr", "rolepath")
+    task = thing(role, :task, "ttt", "taskpath")
+    thing(task, :var, "fff", "fff/varpath")  # fact
+    varfile = thing(role, :varfile, "sss", "sss/varpath")
+    var = thing(varfile, :var, "vvv", "vvv/varpath")
     role[:vardefaults] = []
     role[:template] = []
-    playbook = thing(d, :playbook, "ppp", {:role => [role], :task => [task]})
+    playbook = thing(d, :playbook, "ppp", "playbookpath",
+                     {:role => [role], :task => [task]})
 
     styler = Styler.new
     Grapher.new.add_nodes(@g, d, styler, true)

test-loader.rb

@@ -7,13 +7,15 @@ class TC_Loader < Test::Unit::TestCase
   def test_thing
     d = {}
 
-    it = thing(d, :abc, "def", {"ghi" => "jkl"})
-    it2 = thing(it, :xyz, "456")
+    it = thing(d, :abc, "def", "path", {"ghi" => "jkl"})
+    it2 = thing(it, :xyz, "456", "path2")
 
-    thing1 = {:type=>:abc, :name=>"def", :fqn=>"def", "ghi"=>"jkl", :xyz=>[it2]}
+    thing1 = {:type=>:abc, :name=>"def", :fqn=>"def", "ghi"=>"jkl",
+              :path=>"path", :xyz=>[it2]}
     assert_equal(thing1, it)
 
-    thing2 = {:type=>:xyz, :name=>"456", :fqn=>"def::456", :parent=>it}
+    thing2 = {:type=>:xyz, :name=>"456", :fqn=>"def::456",
+              :path=>"path2", :parent=>it}
     assert_equal(thing2, it2)
     assert_has_all d[:abc], [it]
   end
@@ -46,17 +48,21 @@ def test_role
     assert_has_all %w(main task1 task2), role[:task].smap(:name)
     role.delete(:task)
 
-    expect = thing({}, :role, "role1", {:role_deps => ["roleA"]})
+    expect = thing({}, :role, "role1", "sample/roles/role1",
+                   {:role_deps => ["roleA"]})
     assert_equal expect, role
   end
 
   def test_mk_child
     d = {}
-    role = thing(d, :role, "role")
+    role = thing(d, :role, "role", "rolepath")
     varfile = Loader.new.load_thing(role, :varfile, "sample/roles/role1/vars", "main.yml")
 
     varfile.delete :data
-    expect = thing(thing({}, :role, "role"), :varfile, "main", {:parent => d})
-    assert_equal expect, varfile
+    expected_role = thing({}, :role, "role", "rolepath")
+    expected_varfile = thing(expected_role, :varfile, "main",
+                             "sample/roles/role1/vars/main.yml",
+                             {:parent => d})
+    assert_equal expected_varfile, varfile
   end
 end

test-varfinder.rb

@@ -11,8 +11,8 @@
 
 class TC_FindVars < Test::Unit::TestCase
   def try(expect, input)
-    role = thing({}, :role, "role")
-    task = thing(role, :task, "task1")
+    role = thing({}, :role, "role", "rolepath")
+    task = thing(role, :task, "task1", "taskpath")
     assert_equal expect, VarFinder.new.find_vars_in_task(task, input)
   end
 

test-viz.rb

@@ -14,7 +14,7 @@ def assert_has_all(e, a, m="")
 end
 
 def assert_keys(it, *keys)
-  base = [:type, :name, :fqn]
+  base = [:type, :name, :fqn, :path]
   assert_has_all base + keys, it.keys
 end