Add --ignore-dependencies option to compilestatic command

Author: Andrey Fedoseev

CHANGES.rst

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

docs/compilestatic-command.rst

@@ -9,6 +9,10 @@ You can use this command in conjunction with ``STATIC_PRECOMPILER_DISABLE_AUTO_C
 ``STATICFILES_STORAGE`` such as S3 or some CDN. In that case you can should run ``compilestatic`` every time when your
 source files change and then run ``collectstatic``.
 
+Sometimes it may be useful to prevent dependency tracking when running ``compilestatic``, for example when you don't
+have access to a database (building a Docker image). Use ``--ignore-dependencies`` option to disable the dependency
+tracking.
+
 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/compilers/base.py

@@ -301,14 +301,3 @@ def update_dependencies(self, source_path, dependencies):
                     source=source_path,
                     depends_on=dependency,
                 )
-
-    def handle_changed_file(self, source_path, verbosity=0):
-        """ Handle the modification of the source file.
-
-        :param source_path: relative path to a source file
-        :type source_path: str
-        :type verbosity: int
-        """
-        self.compile(source_path, from_management=True, verbosity=verbosity)
-        for dependent in self.get_dependents(source_path):
-            self.compile(dependent, from_management=True, verbosity=verbosity)

static_precompiler/management/commands/compilestatic.py

@@ -31,27 +31,37 @@ def list_files(scanned_dirs):
                 yield path
 
 
+ARGUMENTS = (
+    ("--ignore-dependencies", dict(
+        action="store_true",
+        dest="ignore_dependencies",
+        default=False,
+        help="Disable dependency tracking, this prevents any database access.",
+     )),
+    ("--watch", dict(
+        action="store_true",
+        dest="watch",
+        default=False,
+        help="Watch for changes and recompile if necessary."
+    )),
+    ("--no-initial-scan", dict(
+        action="store_false",
+        dest="initial_scan",
+        default=True,
+        help="Skip the initial scan of watched directories in --watch mode."
+    )),
+)
+
+
 class Command(django.core.management.base.BaseCommand):
 
     help = "Compile static files."
 
     requires_system_checks = False
 
     def add_arguments(self, parser):
-        parser.add_argument(
-            "--watch",
-            action="store_true",
-            dest="watch",
-            default=False,
-            help="Watch for changes and recompile if necessary."
-        )
-        parser.add_argument(
-            "--no-initial-scan",
-            action="store_false",
-            dest="initial_scan",
-            default=True,
-            help="Skip the initial scan of watched directories in --watch mode."
-        )
+        for argument, parameters in ARGUMENTS:
+            parser.add_argument(argument, **parameters)
 
     def handle(self, **options):
 
@@ -62,6 +72,10 @@ def handle(self, **options):
         verbosity = int(options["verbosity"])
         compilers = registry.get_compilers().values()
 
+        if options["ignore_dependencies"]:
+            for compiler in compilers:
+                compiler.supports_dependencies = False
+
         if not options["watch"] or options["initial_scan"]:
             # Scan the watched directories and compile everything
             for path in sorted(set(list_files(scanned_dirs))):
@@ -75,7 +89,7 @@ def handle(self, **options):
                     continue
 
                 try:
-                    compiler.handle_changed_file(path, verbosity=verbosity)
+                    compiler.compile(path, from_management=True, verbosity=verbosity)
                 except (exceptions.StaticCompilationError, ValueError) as e:
                     print(e)
 
@@ -86,15 +100,6 @@ def handle(self, **options):
 
 if django.VERSION < (1, 8):
     import optparse
-    Command.option_list = django.core.management.base.NoArgsCommand.option_list + (
-        optparse.make_option("--watch",
-                             action="store_true",
-                             dest="watch",
-                             default=False,
-                             help="Watch for changes and recompile if necessary."),
-        optparse.make_option("--no-initial-scan",
-                             action="store_false",
-                             dest="initial_scan",
-                             default=True,
-                             help="Skip the initial scan of watched directories in --watch mode.")
+    Command.option_list = django.core.management.base.NoArgsCommand.option_list + tuple(
+        optparse.make_option(argument, **argument_parameters) for argument, argument_parameters in ARGUMENTS
     )

static_precompiler/tests/test_management.py

@@ -53,3 +53,13 @@ def test_compilestatic_command(verbosity, capsys, monkeypatch, tmpdir):
         )
     else:
         assert stdout == ""
+
+
+@pytest.mark.skip("Re-enable when pytest-django>3.1.2 is released")
+@pytest.mark.django_db
+def test_ignore_dependencies_option(django_assert_num_queries, monkeypatch, tmpdir):
+
+    monkeypatch.setattr("static_precompiler.settings.ROOT", tmpdir.strpath)
+
+    with django_assert_num_queries(0):
+        management.call_command("compilestatic", ignore_dependencies=True)

static_precompiler/watch.py

@@ -1,13 +1,17 @@
 import time
 
+from typing import *  # noqa
 from watchdog import events, observers
 
 from . import exceptions, registry
+from .compilers import BaseCompiler  # noqa
 
 
 class EventHandler(events.FileSystemEventHandler):
 
+    # noinspection PyShadowingNames
     def __init__(self, scanned_dir, verbosity, compilers):
+        # type: (str, int, List[BaseCompiler]) -> None
         self.scanned_dir = scanned_dir
         self.verbosity = verbosity
         self.compilers = compilers
@@ -24,7 +28,11 @@ def on_any_event(self, e):
                 if self.verbosity > 1:
                     print("Modified: '{0}'".format(path))
                 try:
-                    compiler.handle_changed_file(path)
+                    compiler.compile(path, from_management=True, verbosity=self.verbosity)
+                    if compiler.supports_dependencies:
+                        for dependent in compiler.get_dependents(path):
+                            compiler.compile(path, from_management=True, verbosity=self.verbosity)
+                            self.compile(dependent, from_management=True, verbosity=self.verbosity)
                 except (exceptions.StaticCompilationError, ValueError) as e:
                     print(e)
                 break