Merge pull request #68 from andreyfedoseev/source-maps

Add support for source maps

Author: Andrey Fedoseev

CHANGES.rst

@@ -2,6 +2,16 @@
 Changes
 =======
 
+Dev
+===
+
+- Add source maps support for SASS/SCSS
+- Add source maps support for LESS
+- Add source maps support for CoffeeScript
+- Add source maps support for Stylus
+- Add source maps support for Babel
+
+
 1.0.1
 =====
 

README.rst

@@ -174,10 +174,13 @@ CoffeeScript
 ``executable``
   Path to CoffeeScript compiler executable. Default: ``"coffee"``.
 
+``sourcemap_enabled``
+  Boolean. Set to ``True`` to enable source maps. Default: ``False``
+
 Example::
 
     STATIC_PRECOMPILER_COMPILERS = (
-        ('static_precompiler.compilers.CoffeeScript', {"executable": "/usr/bin/coffee"}),
+        ('static_precompiler.compilers.CoffeeScript', {"executable": "/usr/bin/coffee", "sourcemap_enabled": True}),
     )
 
 
@@ -187,13 +190,16 @@ Babel
 ``executable``
   Path to Babel compiler executable. Default: ``"babel"``.
 
+``sourcemap_enabled``
+  Boolean. Set to ``True`` to enable source maps. Default: ``False``
+
 ``modules``
   Babel `modules <https://babeljs.io/docs/usage/modules/>`_ command line option. Default: ``None`` (uses Babel's default option).
 
 Example::
 
     STATIC_PRECOMPILER_COMPILERS = (
-        ('static_precompiler.compilers.Babel', {"executable": "/usr/bin/babel", "modules": "amd"}),
+        ('static_precompiler.compilers.Babel', {"executable": "/usr/bin/babel", "sourcemap_enabled": True, "modules": "amd"}),
     )
 
 
@@ -203,13 +209,16 @@ SASS / SCSS
 ``executable``
   Path to SASS compiler executable. Default: "sass".
 
+``sourcemap_enabled``
+  Boolean. Set to ``True`` to enable source maps. Default: ``False``
+
 ``compass_enabled``
   Boolean. Whether to use compass or not. Compass must be installed in your system. Run "sass --compass" and if no error is shown it means that compass is installed.
 
 Example::
 
     STATIC_PRECOMPILER_COMPILERS = (
-        ('static_precompiler.compilers.SCSS', {"executable": "/usr/bin/sass", "compass_enabled": True}),
+        ('static_precompiler.compilers.SCSS', {"executable": "/usr/bin/sass", "sourcemap_enabled": True, "compass_enabled": True}),
     )
 
 
@@ -219,10 +228,13 @@ LESS
 ``executable``
   Path to LESS compiler executable. Default: ``"lessc"``.
 
+``sourcemap_enabled``
+  Boolean. Set to ``True`` to enable source maps. Default: ``False``
+
 Example::
 
     STATIC_PRECOMPILER_COMPILERS = (
-        ('static_precompiler.compilers.LESS', {"executable": "/usr/bin/lessc"),
+        ('static_precompiler.compilers.LESS', {"executable": "/usr/bin/lessc", "sourcemap_enabled": True),
     )
 
 
@@ -232,10 +244,13 @@ Stylus
 ``executable``
   Path to Stylus compiler executable. Default: ``"stylus"``.
 
+``sourcemap_enabled``
+  Boolean. Set to ``True`` to enable source maps. Default: ``False``
+
 Example::
 
     STATIC_PRECOMPILER_COMPILERS = (
-        ('static_precompiler.compilers.Stylus', {"executable": "/usr/bin/stylus"),
+        ('static_precompiler.compilers.Stylus', {"executable": "/usr/bin/stylus", "sourcemap_enabled": True),
     )
 
 

static_precompiler/compilers/babel.py

@@ -1,3 +1,7 @@
+import json
+import os
+import posixpath
+
 from static_precompiler import exceptions, utils
 
 from . import base
@@ -13,13 +17,52 @@ class Babel(base.BaseCompiler):
     input_extension = "es6"
     output_extension = "js"
 
-    def __init__(self, executable="babel", modules=None):
+    def __init__(self, executable="babel", sourcemap_enabled=False, modules=None):
         self.executable = executable
+        self.is_sourcemap_enabled = sourcemap_enabled
         self.modules = modules
         super(Babel, self).__init__()
 
     def compile_file(self, source_path):
-        return self.compile_source(self.get_source(source_path))
+        args = [
+            self.executable,
+        ]
+
+        if self.is_sourcemap_enabled:
+            args.append("-s")
+
+        if self.modules is not None:
+            args.extend(["--modules", self.modules])
+
+        full_output_path = self.get_full_output_path(source_path)
+
+        full_output_dirname = os.path.dirname(full_output_path)
+        if not os.path.exists(full_output_dirname):
+            os.makedirs(full_output_dirname)
+
+        args.extend(["-o", full_output_path])
+        args.append(self.get_full_source_path(source_path))
+
+        out, errors = utils.run_command(args)
+        if errors:
+            raise exceptions.StaticCompilationError(errors)
+
+        if self.is_sourcemap_enabled:
+            sourcemap_full_path = full_output_path + ".map"
+
+            with open(sourcemap_full_path) as sourcemap_file:
+                sourcemap = json.loads(sourcemap_file.read())
+
+            # Babel can't add correct relative paths in source map when the compiled file
+            # is not in the same dir as the source file. We fix it here.
+            sourcemap["sourceRoot"] = "../" * len(source_path.split("/")) + posixpath.dirname(source_path)
+            sourcemap["sources"] = [os.path.basename(source) for source in sourcemap["sources"]]
+            sourcemap["file"] = posixpath.basename(os.path.basename(full_output_path))
+
+            with open(sourcemap_full_path, "w") as sourcemap_file:
+                sourcemap_file.write(json.dumps(sourcemap))
+
+        return self.get_output_path(source_path)
 
     def compile_source(self, source):
         args = [

static_precompiler/compilers/base.py

@@ -164,24 +164,6 @@ def get_source(self, source_path):
         with open(self.get_full_source_path(source_path)) as source:
             return source.read()
 
-    def write_output(self, output, source_path):
-        """ Write the compiled output to a file.
-
-        :param output: compiled code
-        :type output: str
-        :param source_path: relative path to a source file
-        :type source_path: str
-
-        """
-        output_path = self.get_full_output_path(source_path)
-        output_dir = os.path.dirname(output_path)
-        if not os.path.exists(output_dir):
-            os.makedirs(output_dir)
-
-        compiled_file = open(output_path, "w+")
-        compiled_file.write(output)
-        compiled_file.close()
-
     def compile(self, source_path, from_management=False):
         """ Compile the given source path and return relative path to the compiled file.
             Raise ValueError is the source file type is not supported.
@@ -198,18 +180,19 @@ def compile(self, source_path, from_management=False):
             raise ValueError("'{0}' file type is not supported by '{1}'".format(
                 source_path, self.__class__.__name__
             ))
+
+        compliled_path = self.get_output_path(source_path)
+
         if self.should_compile(source_path, from_management=from_management):
 
-            compiled = self.compile_file(source_path)
-            compiled = self.postprocess(compiled, source_path)
-            self.write_output(compiled, source_path)
+            compliled_path = self.compile_file(source_path)
 
             if self.supports_dependencies:
                 self.update_dependencies(source_path, self.find_dependencies(source_path))
 
             logging.info("Compiled: '{0}'".format(source_path))
 
-        return self.get_output_path(source_path)
+        return compliled_path
 
     def compile_lazy(self, source_path):
         """ Return a lazy object which, when translated to string, compiles the specified source path and returns
@@ -226,7 +209,7 @@ def compile_lazy(self, source_path):
     compile_lazy = functional.lazy(compile_lazy, six.text_type)
 
     def compile_file(self, source_path):
-        """ Compile the source file. Return the compiled code.
+        """ Compile the source file. Return the relative path to compiled file.
             May raise a StaticCompilationError if something goes wrong with compilation.
 
         :param source_path: path to the source file
@@ -247,18 +230,6 @@ def compile_source(self, source):
         """
         raise NotImplementedError
 
-    # noinspection PyMethodMayBeStatic,PyUnusedLocal
-    def postprocess(self, compiled, source_path):
-        """ Post-process the compiled code.
-
-        :param compiled: compiled code
-        :type compiled: str
-        :param source_path: relative path to a source file
-        :type source_path: str
-        :returns: str
-        """
-        return compiled
-
     def find_dependencies(self, source_path):
         """ Find the dependencies for the given source file.
 

static_precompiler/compilers/coffeescript.py

@@ -1,3 +1,7 @@
+import json
+import os
+import posixpath
+
 from static_precompiler import exceptions, settings, utils
 
 from . import base
@@ -13,12 +17,45 @@ class CoffeeScript(base.BaseCompiler):
     input_extension = "coffee"
     output_extension = "js"
 
-    def __init__(self, executable=settings.COFFEESCRIPT_EXECUTABLE):
+    def __init__(self, executable=settings.COFFEESCRIPT_EXECUTABLE, sourcemap_enabled=False):
         self.executable = executable
+        self.is_sourcemap_enabled = sourcemap_enabled
         super(CoffeeScript, self).__init__()
 
     def compile_file(self, source_path):
-        return self.compile_source(self.get_source(source_path))
+        full_output_path = self.get_full_output_path(source_path)
+        args = [
+            self.executable,
+            "-c",
+        ]
+        if self.is_sourcemap_enabled:
+            args.append("-m")
+        args.extend([
+            "-o", os.path.dirname(full_output_path),
+            self.get_full_source_path(source_path),
+        ])
+        out, errors = utils.run_command(args)
+
+        if errors:
+            raise exceptions.StaticCompilationError(errors)
+
+        if self.is_sourcemap_enabled:
+            # Coffeescript writes source maps to compiled.map, not compiled.js.map
+            sourcemap_full_path = os.path.splitext(full_output_path)[0] + ".map"
+
+            with open(sourcemap_full_path) as sourcemap_file:
+                sourcemap = json.loads(sourcemap_file.read())
+
+            # CoffeeScript, unlike SASS, can't add correct relative paths in source map when the compiled file
+            # is not in the same dir as the source file. We fix it here.
+            sourcemap["sourceRoot"] = "../" * len(source_path.split("/")) + posixpath.dirname(source_path)
+            sourcemap["sources"] = [os.path.basename(source) for source in sourcemap["sources"]]
+            sourcemap["file"] = posixpath.basename(os.path.basename(full_output_path))
+
+            with open(sourcemap_full_path, "w") as sourcemap_file:
+                sourcemap_file.write(json.dumps(sourcemap))
+
+        return self.get_output_path(source_path)
 
     def compile_source(self, source):
         args = [

static_precompiler/compilers/less.py

@@ -1,3 +1,4 @@
+import json
 import os
 import posixpath
 import re
@@ -21,8 +22,9 @@ class LESS(base.BaseCompiler):
     IMPORT_RE = re.compile(r"@import\s+(.+?)\s*;", re.DOTALL)
     IMPORT_ITEM_RE = re.compile(r"([\"'])(.+?)\1")
 
-    def __init__(self, executable=settings.LESS_EXECUTABLE):
+    def __init__(self, executable=settings.LESS_EXECUTABLE, sourcemap_enabled=False):
         self.executable = executable
+        self.is_sourcemap_enabled = sourcemap_enabled
         super(LESS, self).__init__()
 
     def should_compile(self, source_path, from_management=False):
@@ -33,18 +35,46 @@ def should_compile(self, source_path, from_management=False):
 
     def compile_file(self, source_path):
         full_source_path = self.get_full_source_path(source_path)
-        args = [
-            self.executable,
-            full_source_path,
-        ]
+        full_output_path = self.get_full_output_path(source_path)
+
         # `cwd` is a directory containing `source_path`.
         # Ex: source_path = '1/2/3', full_source_path = '/abc/1/2/3' -> cwd = '/abc'
         cwd = os.path.normpath(os.path.join(full_source_path, *([".."] * len(source_path.split("/")))))
-        out, errors = utils.run_command(args, None, cwd=cwd)
+
+        args = [
+            self.executable
+        ]
+        if self.is_sourcemap_enabled:
+            args.extend([
+                "--source-map"
+            ])
+
+        args.extend([
+            self.get_full_source_path(source_path),
+            full_output_path,
+        ])
+        out, errors = utils.run_command(args, cwd=cwd)
         if errors:
             raise exceptions.StaticCompilationError(errors)
 
-        return out
+        utils.convert_urls(full_output_path, source_path)
+
+        if self.is_sourcemap_enabled:
+            sourcemap_full_path = full_output_path + ".map"
+
+            with open(sourcemap_full_path) as sourcemap_file:
+                sourcemap = json.loads(sourcemap_file.read())
+
+            # LESS, unlike SASS, can't add correct relative paths in source map when the compiled file
+            # is not in the same dir as the source file. We fix it here.
+            sourcemap["sourceRoot"] = "../" * len(source_path.split("/")) + posixpath.dirname(source_path)
+
+            sourcemap["file"] = posixpath.basename(full_output_path)
+
+            with open(sourcemap_full_path, "w") as sourcemap_file:
+                sourcemap_file.write(json.dumps(sourcemap))
+
+        return self.get_output_path(source_path)
 
     def compile_source(self, source):
         args = [
@@ -59,9 +89,6 @@ def compile_source(self, source):
 
         return out
 
-    def postprocess(self, compiled, source_path):
-        return utils.convert_urls(compiled, source_path)
-
     def find_imports(self, source):
         """ Find the imported files in the source code.