Add --delete-stale-files option to compilestatic command

Author: Andrey Fedoseev

CHANGES.rst

@@ -7,6 +7,7 @@ Dev
 
  - Remove deprecated settings: ``COFFEESCRIPT_EXECUTABLE``, ``SCSS_EXECUTABLE``, ``SCSS_USE_COMPASS``, ``LESS_EXECUTABLE``
  - Add ``--ignore-dependencies`` option to ``compilestatic`` command
+ - Add ``--delete-stale-files`` option to ``compilestatic`` command
 
 1.7.1
 =====

docs/compilestatic-command.rst

@@ -13,6 +13,11 @@ Sometimes it may be useful to prevent dependency tracking when running ``compile
 have access to a database (building a Docker image). Use ``--ignore-dependencies`` option to disable the dependency
 tracking.
 
+``--delete-stale-files`` option may be used to delete compiled files that no longer have matching source files.
+Example: you have a ``styles.scss`` which get compiled to ``styles.css``. If you remove the source file ``styles.scss``
+and run ``compilestatic --delete-stale-files`` it will compile the files as usual, and delete the stale ``styles.css``
+file.
+
 You can run ``compilestatic`` in watch mode (``--watch`` option). In watch mode it will monitor the changes in your
 source files and re-compile them on the fly. It can be handy if you use tools such as
 `LiveReload <http://livereload.com/>`_.

static_precompiler/management/commands/compilestatic.py

@@ -6,7 +6,7 @@
 import django.core.files.storage
 import django.core.management.base
 
-from ... import exceptions, registry, settings
+from ... import exceptions, registry, settings, utils
 
 
 def get_scanned_dirs():
@@ -31,13 +31,32 @@ def list_files(scanned_dirs):
                 yield path
 
 
+def delete_stale_files(compiled_files):
+    compiled_files = set(
+        os.path.join(settings.ROOT, utils.normalize_path(compiled_file)) for compiled_file in compiled_files
+    )
+    actual_files = set()
+    for dirname, dirnames, filenames in os.walk(os.path.join(settings.ROOT, settings.OUTPUT_DIR)):
+        for filename in filenames:
+            actual_files.add(os.path.join(dirname, filename))
+    stale_files = actual_files - compiled_files
+    for stale_file in stale_files:
+        os.remove(stale_file)
+
+
 ARGUMENTS = (
     ("--ignore-dependencies", dict(
         action="store_true",
         dest="ignore_dependencies",
         default=False,
         help="Disable dependency tracking, this prevents any database access.",
-     )),
+    )),
+    ("--delete-stale-files", dict(
+        action="store_true",
+        dest="delete_stale_files",
+        default=False,
+        help="Delete compiled files don't have matching source files.",
+    )),
     ("--watch", dict(
         action="store_true",
         dest="watch",
@@ -78,6 +97,7 @@ def handle(self, **options):
 
         if not options["watch"] or options["initial_scan"]:
             # Scan the watched directories and compile everything
+            compiled_files = set()
             for path in sorted(set(list_files(scanned_dirs))):
                 for compiler in compilers:
                     if compiler.is_supported(path):
@@ -89,10 +109,15 @@ def handle(self, **options):
                     continue
 
                 try:
-                    compiler.compile(path, from_management=True, verbosity=verbosity)
+                    compiled_files.add(
+                        compiler.compile(path, from_management=True, verbosity=verbosity)
+                    )
                 except (exceptions.StaticCompilationError, ValueError) as e:
                     print(e)
 
+            if options["delete_stale_files"]:
+                delete_stale_files(compiled_files)
+
         if options["watch"]:
             from static_precompiler.watch import watch_dirs
             watch_dirs(scanned_dirs, verbosity)

static_precompiler/tests/test_management.py

@@ -66,3 +66,41 @@ def test_ignore_dependencies_option(django_assert_num_queries, monkeypatch, tmpd
 
     with django_assert_num_queries(0):
         management.call_command("compilestatic", ignore_dependencies=True)
+
+
+@pytest.mark.django_db
+def test_delete_stale_files(monkeypatch, tmpdir):
+
+    output_path = os.path.join(tmpdir.strpath, static_precompiler.settings.OUTPUT_DIR)
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+
+    unmanaged_file = os.path.join(tmpdir.strpath, "unmanaged.js")
+    with open(unmanaged_file, "w+") as f:
+        f.write("unmanaged")
+
+    with open(os.path.join(output_path, "stale.js"), "w+") as f:
+        f.write("stale")
+
+    monkeypatch.setattr("static_precompiler.management.commands.compilestatic.get_scanned_dirs", lambda: (
+        os.path.join(os.path.dirname(__file__), "compilestatic"),
+    ))
+    monkeypatch.setattr("static_precompiler.settings.ROOT", tmpdir.strpath)
+
+    management.call_command("compilestatic", delete_stale_files=True)
+
+    compiled_files = []
+    for root, dirs, files in os.walk(output_path):
+        for filename in files:
+            compiled_files.append(os.path.join(root[len(output_path):].lstrip("/"), filename))
+
+    compiled_files.sort()
+
+    assert compiled_files == [
+        "coffee/test.js",
+        "less/test.css",
+        "scss/test.css",
+    ]
+
+    # Files outside of `COMPILED` directory are untouched
+    assert os.path.exists(unmanaged_file)