@@ -2,6 +2,7 @@
 
 import argparse
 import sys, re, os
+import sqlite3
 
 try:
     from lxml import etree
@@ -41,15 +42,15 @@ def warn(s):
 def fail(s):
     sys.stdout.write("failure: %s\n" % s)
 
-def test_not_anchored(tree):
+def test_not_anchored(tree, fi):
     # Rules not anchored to the beginning of a line.
     """The 'from' rule is not anchored to beginning of line using the ^ symbol."""
     for f in tree.xpath("/ruleset/rule/@from"):
         if not f or f[0] != "^":
             return False
     return True
 
-def test_bad_regexp(tree):
+def test_bad_regexp(tree, fi):
     # Rules with invalid regular expressions.
     """The 'from' rule contains an invalid extended regular expression."""
     for f in tree.xpath("/ruleset/rule/@from") + \
@@ -61,20 +62,19 @@ def test_bad_regexp(tree):
             return False
     return True
 
-def test_missing_to(tree):
-
+def test_missing_to(tree, fi):
     # Rules that are terminated before setting 'to'.
     # These cases are probably either due to a misplaced
     # rule end or intended to be different elements.
     """Rule is missing a 'to' value."""
     for rule in tree.xpath("/ruleset/rule"):
-	if not rule.get("to"):
-            warn("'to' attribute missing in %s. " %fi)
+        if not rule.get("to"):
+            warn("'to' attribute missing in %s. " % fi)
             warn("Misplaced end or misnamed element?")
             return False
     return True
 
-def test_unescaped_dots(tree):
+def test_unescaped_dots(tree, fi):
     # Rules containing unescaped dots outside of brackets and before slash.
     # Note: this is meant to require example\.com instead of example.com,
     # but it also forbids things like .* which usually ought to be replaced
@@ -99,15 +99,15 @@ def test_unescaped_dots(tree):
                escaped = False
     return True
 
-def test_space_in_to(tree):
+def test_space_in_to(tree, fi):
     # Rules where the to pattern contains a space.
     """The 'to' rule contains a space."""
     for t in tree.xpath("/ruleset/rule/@to"):
         if ' ' in t:
             return False
     return True
 
-def test_unencrypted_to(tree):
+def test_unencrypted_to(tree, fi):
     # Rules that redirect to something other than https or http.
     # This used to test for http: but testing for lack of https: will
     # catch more kinds of mistakes.
@@ -125,15 +125,15 @@ def test_unencrypted_to(tree):
             return False
     return True
 
-def test_backslash_in_to(tree):
+def test_backslash_in_to(tree, fi):
     # Rules containing backslashes in to pattern.
     """The 'to' rule contains a backslash."""
     for t in tree.xpath("/ruleset/rule/@to"):
         if '\\' in t:
             return False
     return True
 
-def test_no_trailing_slash(tree):
+def test_no_trailing_slash(tree, fi):
     # Rules not containing trailing slash in from or to pattern.
     """Rule omits forward slash after host name."""
     for r in tree.xpath("/ruleset/rule"):
@@ -144,12 +144,12 @@ def test_no_trailing_slash(tree):
             return False
     return True
 
-def test_lacks_target_host(tree):
+def test_lacks_target_host(tree, fi):
     # Rules that lack at least one target host (target tag with host attr).
     """Rule fails to specify at least one target host."""
     return not not tree.xpath("/ruleset/target/@host")
 
-def test_bad_target_host(tree):
+def test_bad_target_host(tree, fi):
     # Rules where a target host contains multiple wildcards or a slash.
     """The target host must be a hostname, not URL, and must use at most one wildcard."""
     for target in tree.xpath("/ruleset/target/@host"):
@@ -159,15 +159,15 @@ def test_bad_target_host(tree):
             return False
     return True
 
-def test_duplicated_target_host(tree):
+def test_duplicated_target_host(tree, fi):
     # Rules where a single target host appears more than once.
     """Rule contains the same target host more than once."""
     targets = tree.xpath("/ruleset/target/@host")
     return len(set(targets)) == len(targets)
 
 printable_characters = set(map(chr, list(range(32, 127))))
 
-def test_non_ascii(tree):
+def test_non_ascii(tree, fi):
     # Rules containing non-printable characters.
     """Rule contains non-printable character in 'to' pattern."""
     for t in tree.xpath("/ruleset/rule/@to"):
@@ -214,53 +214,36 @@ def nomes_all(where=sys.argv[1:]):
 
 tests = [test_not_anchored, test_bad_regexp, test_unescaped_dots, test_missing_to,
          test_space_in_to, test_unencrypted_to, test_backslash_in_to,
-         test_no_trailing_slash, test_lacks_target_host, test_bad_target_host,
+         test_no_trailing_slash,  test_bad_target_host,
          test_duplicated_target_host, test_non_ascii]
 
 failure = 0
 seen_file = False
-all_names, all_targets = get_all_names_and_targets(dupdir)
 
-for fi in nomes_all():
+conn = sqlite3.connect(os.path.join(os.path.dirname(__file__), '../src/defaults/rulesets.sqlite'))
+c = conn.cursor()
+for row in c.execute('''SELECT contents from rulesets'''):
     try:
-        tree = etree.parse(fi)
-        if fi[-4:] != ".xml":
-            if tree.xpath("/ruleset"):
-                warn("ruleset in file without .xml extension: %s" % fi)
-            else:
-                continue
-        seen_file = True
+        tree = etree.fromstring(row[0])
     except Exception as oops:
-        if fi[-4:] != ".xml":
-            continue
         failure = 1
-        fail("%s failed XML validity: %s\n" % (fi, oops))
+        print("failed XML validity: %s\n" % (oops))
     if failure or not tree.xpath("/ruleset"):
         continue
     if not test_ruleset_name(tree):
         failure = 1
-        fail("unnamed ruleset: %s" % fi)
+        fail("unnamed ruleset")
         continue
     ruleset_name = tree.xpath("/ruleset/@name")[0]
-    if ruleset_name in all_names:
-        failure = 1
-        fail("duplicate ruleset name %s" % ruleset_name)
-    all_names.add(ruleset_name)
+    ruleset_file = tree.xpath("/ruleset/@f")[0]
     for test in tests:
-        if not test(tree):
-            failure = 1
-            fail("%s failed test: %s" % (fi, test.__doc__))
+        if not test(tree, ruleset_file):
+            print("%s failed test: %s" % (ruleset_file, test.__doc__))
     for target in tree.xpath("/ruleset/target/@host"):
         if target in all_targets and not any(ign.search(target) for ign in ignoredups):
             # suppress warning about duplicate targets if an --ignoredups
             # pattern matches target
-            warn("%s has duplicate target: %s" % (fi, target))
+            warn("has duplicate target: %s" % (target))
         all_targets.add(target)
 
-if not seen_file:
-   which = "specified" if args else "current"
-   sys.stdout.write("There were no valid XML files in the %s " % which)
-   sys.stdout.write("directory.\n")
-   failure = 3
-
 sys.exit(failure)