Two bugfixes to the reverse rule generator Lua script

1) Part of rules were left out because of a bug

2) Now reverses conditional mapping rules, too (previously those were
   not reversed at all)
   There was even a "FIXME"-comment about this; the comment stated
   "...This should be fixed, even if it is not a problem with our current
   official mapping modes." This comment was valid once, but not anymore;
   recent changes to the mapping modes practically require that we
   have reverse rules also for conditional rules.

1 files changed, 116 insertions, 48 deletions

diff --git a/lua_scripts/create_reverse_rules.lua b/lua_scripts/create_reverse_rules.lua
index ae79eb3..66a80e9 100644
--- a/lua_scripts/create_reverse_rules.lua
+++ b/lua_scripts/create_reverse_rules.lua
@@ -10,16 +10,11 @@
 -- available and SB2 works just as it did before this feature was implemented)
 --
 -- FIXME:
--- 1. Rules with conditional actions are not reversed correctly. Basically,
--- this script just gives up and marks the destinations with "use_orig_path".
--- This should be fixed, even if it is not a problem with our current
--- "official" mapping modes.
---
--- 2. Reverse rules won't be created if the forward rules use "func_name"
+-- 1. Reverse rules won't be created if the forward rules use "func_name"
 -- conditions. It might be possible to fix that, but "func_names" certainly
 -- complicate sorting of the generated reversing rules.
 --
--- 3. Rule chains with "next_chain" set to something else than 'nil'
+-- 2. Rule chains with "next_chain" set to something else than 'nil'
 -- are not currently supported.
 
 allow_reversing = true	-- default = create reverse rules.
@@ -30,30 +25,49 @@ function test_rev_rule_position(output_rules, d_path)
         local n
         for n=1,table.maxn(output_rules) do
 		local rule = output_rules[n]
-		if (rule.prefix and (rule.prefix ~= "") and
-		    (isprefix(rule.prefix, d_path))) then
-			return n
-		end
-		-- "path" rules: (exact match)
-		if (rule.path == d_path) then
+		local cmp_result
+		cmp_result = sb.test_path_match(d_path,
+			rule.dir, rule.prefix, rule.path)
+		if (cmp_result >= 0) then
 			return n
 		end
 	end
 	return nil
 end
 
-function reverse_one_rule(output_rules, rule, n)
-		local new_rule = {}
-		new_rule.comments = {}
+function is_identical_reverse_rule(r1,r2)
+	if ((r1.prefix == r2.prefix) and
+	    (r1.path == r2.path) and
+	    (r1.dir == r2.dir) and
+	    (r1.replace_by == r2.replace_by)) then
+		return true
+	end
+	return false
+end
 
-		if rule.name then
-			new_rule.name = string.format(
-				"Rev: %s (%d)", rule.name, n)
-		else
-			new_rule.name = string.format(
-				"Rev: Rule %d", n)
-		end
+function reverse_conditional_actions(output_rules, rev_rule_name, rule, n, forward_path)
+	local actions = rule.actions
+
+	local a
+        for a = 1, table.maxn(actions) do
+		-- actions are only partial rules; the "selector" is in
+		-- "rule", but we must copy it temporarily to action[a],
+		-- otherwise reverse_one_rule_xxxx() won't be able to
+		-- process it completely. Also, invent a better 
+		-- temporary name for it.
+		actions[a].prefix = rule.prefix
+		actions[a].path = rule.path
+		actions[a].dir = rule.dir
+		actions[a].name = string.format("%s/Act.%d", rev_rule_name, a)
+		reverse_one_rule_xxxx(output_rules, actions[a], a, forward_path)
+		actions[a].prefix = nil
+		actions[a].path = nil
+		actions[a].dir = nil
+		actions[a].name = nil
+	end
+end
 
+function reverse_one_rule(output_rules, rule, n)
 		local forward_path
 		if (rule.prefix) then
 			forward_path = rule.prefix
@@ -63,8 +77,35 @@ function reverse_one_rule(output_rules, rule, n)
 			forward_path = rule.dir
 		else
 			forward_path = nil
+		end
+		reverse_one_rule_xxxx(output_rules, rule, n, forward_path)
+end
+
+function reverse_one_rule_xxxx(output_rules, rule, n, forward_path)
+
+		local new_rule = {}
+		new_rule.comments = {}
+
+		if rule.name then
+			new_rule.name = string.format(
+				"Rev: %s <%d>", rule.name, n)
+		else
+			local auto_name = "??"
+			if (rule.prefix) then
+				auto_name = "prefix="..rule.prefix
+			elseif (rule.dir) then
+				auto_name = "dir="..rule.dir
+			elseif (rule.path) then
+				auto_name = "path="..rule.path
+			end
+			new_rule.name = string.format(
+				"Rev: %s <%d>", auto_name, n)
+		end
+
+
+		if (forward_path == nil) then
 			new_rule.error = string.format(
-				"--ERROR: Rule '%s' does not contain 'prefix' or 'path'",
+				"--ERROR: Rule '%s' does not contain 'prefix' 'dir' or 'path'",
 				new_rule.name)
 		end
 
@@ -80,9 +121,9 @@ function reverse_one_rule(output_rules, rule, n)
 			new_rule.use_orig_path = true
 			d_path = forward_path
 		elseif (rule.actions) then
-			-- FIXME: To be implemented. See the "TODO" list at top.
-			new_rule.use_orig_path = true
-			d_path = forward_path
+			reverse_conditional_actions(output_rules, new_rule.name,
+				rule, n, forward_path)
+			return
 		elseif (rule.map_to) then
 			d_path = rule.map_to .. forward_path
 			new_rule.replace_by = forward_path
@@ -93,6 +134,12 @@ function reverse_one_rule(output_rules, rule, n)
 			new_rule.error = string.format(
 				"--Notice: custom_map_funct rules can't be reversed, please mark it 'virtual'",
 				new_rule.name)
+		elseif (rule.if_exists_then_map_to) then
+			d_path = rule.if_exists_then_map_to .. forward_path
+			new_rule.replace_by = forward_path
+		elseif (rule.if_exists_then_replace_by) then
+			d_path = rule.if_exists_then_replace_by
+			new_rule.replace_by = forward_path
 		else
 			new_rule.error = string.format(
 				"--ERROR: Rule '%s' does not contain any actions",
@@ -105,6 +152,10 @@ function reverse_one_rule(output_rules, rule, n)
 				new_rule.prefix = d_path
 				new_rule.orig_prefix = rule.prefix
 				idx = test_rev_rule_position(output_rules, d_path..":")
+			elseif (rule.dir) then
+				new_rule.dir = d_path
+				new_rule.orig_path = rule.dir
+				idx = test_rev_rule_position(output_rules, d_path)
 			elseif (rule.path) then
 				new_rule.path = d_path
 				new_rule.orig_path = rule.path
@@ -117,35 +168,50 @@ function reverse_one_rule(output_rules, rule, n)
 			table.insert(new_rule.comments, string.format(
 				"--NOTE: '%s' conflicts with '%s', reorganized",
 				new_rule.name, output_rules[idx].name))
+			if (is_identical_reverse_rule(new_rule,output_rules[idx])) then
+				table.insert(output_rules[idx].comments,
+					string.format("--NOTE: Identical rule '%s' generated (dropped)",
+					new_rule.name))
+			else
+				local x_path = nil
+				local older_rule = output_rules[idx]
+				if (older_rule.prefix) then
+					x_path = older_rule.prefix
+				elseif (older_rule.dir) then
+					x_path = older_rule.dir
+				elseif (older_rule.path) then
+					x_path = older_rule.path
+				end
 
-			local x_path = nil
-			if (output_rules[idx].prefix) then
-				x_path = output_rules[idx].prefix
-			elseif (output_rules[idx].path) then
-				x_path = output_rules[idx].path
-			end
-
-			table.insert(output_rules, idx, new_rule)
-			
-			if x_path then
-				local idx2
-				idx2 = test_rev_rule_position(output_rules, x_path)
+				if x_path then
+					local dummy_rules = {}
+					dummy_rules[1] = new_rule
+					dummy_rules[2] = older_rule
+					local idx2
+					idx2 = test_rev_rule_position(dummy_rules, x_path)
 
-				if idx2 ~= idx+1 then
-					table.insert(new_rule.comments, string.format(
-						"--NOTE: '%s' DOUBLE CONFLICT with '%s'",
-						new_rule.name, output_rules[idx].name))
+					if idx2 ~= 2 then
+						-- x_path (selector for the older rule)
+						-- hit the new_rule, not the older rule.
+						-- Two targets were mapped to the same place,
+						-- can't reverse one path to two locations..
+						table.insert(older_rule.comments, string.format(
+							"--NOTE: '%s' WOULD CONFLICT with '%s', conflicting rule dropped",
+							new_rule.name, older_rule.name))
+					else
+						table.insert(output_rules, idx, new_rule)
+					end
+				else
+					table.insert(output_rules, idx, new_rule)
 				end
 			end
-
 		else
 			-- no conflicts
 			table.insert(output_rules, new_rule)
 		end
 end
 
-function reverse_rules(input_rules)
-	local output_rules = {}
+function reverse_rules(output_rules, input_rules)
         local n
         for n=1,table.maxn(input_rules) do
 		local rule = input_rules[n]
@@ -154,7 +220,7 @@ function reverse_rules(input_rules)
 			-- don't reverse virtual paths
 			print("-- virtual_path set, not reversing", n)
 		elseif rule.chain then
-			reverse_rules(rule.chain.rules)
+			reverse_rules(output_rules, rule.chain.rules)
 		else
 			reverse_one_rule(output_rules, rule, n)
 		end
@@ -211,6 +277,7 @@ function print_rules(rules)
 		end
 		print("\t},")
 	end
+        print("-- Printed",table.maxn(rules),"rules")
 end
 
 function process_chains(chains_table)
@@ -241,7 +308,8 @@ function process_chains(chains_table)
 				print("    binary=nil,")
 			end
 
-			local rev_rules = reverse_rules(chains_table[n].rules)
+			local output_rules = {}
+			local rev_rules = reverse_rules(output_rules, chains_table[n].rules)
 			if (allow_reversing) then
 				print("    rules={")
 				print_rules(rev_rules)