No option to enable source-maps

[daGrevis]

Because command-line args are hardcoded, it's currently improssible to enable source-maps.

django-static-precompiler/static_precompiler/compilers/coffeescript.py

Lines 21 to 26 in 468256f

	args = [
	self.executable,
	"-c",
	"-s",
	"-p",
	]

[andreyfedoseev]

Adding support for source maps is on the roadmap, but it's not as easy as adding a command line argument to compiler.

[jaheba]

Speaking at least for babel, source-map files are currently not possible with the current approach how files are compiled (using stdout). It would be possible to use inline source-maps, but this has increased the file size by factor 3 in a quick test on one of my files (8 to 25kb).

Instead the corresponding call (in Babel's case) needs to include --out-file <target> (or --out-dir). The source map will then be generated (--source-maps true) and put in the same folder as the original target.

I think I will try to implement it for Babel and we can then discuss how well it fits in the existing architecture.

[jaheba]

jaheba/django-static-precompiler@561f468

This is a quickly hacked implementation which enables source maps for babel.

I added compile_source_to_file, which replaces the following calls:

compiled = self.compile_file(source_path)
compiled = self.postprocess(compiled, source_path)
self.write_output(compiled, source_path)

In babel I override this method and force source maps via the command line options. I also have to specify the input and output file as described in my previous post.

However that method would sacrifice the possibility to use postprocess. Maybe it is possible to use a preprocess instead and then compile the file, since post processing the file may likely destroy the source map.

[jaheba]

Alright, I just checked the sass compiler and it has the same problem as babel: It requires specified input and output files for source maps. In other words, it is not possible to have source maps with the current pipe concept.
This at least implies a rewrite of the current code base, and things get even more complicate when postprocess still should be supported.

Ideas?

[andreyfedoseev]

I began to work on source maps support, see source-maps branch.

@jaheba I reworked the file compilation workflow compile_file, it doesn't rely on stdout now.

[jaheba]

I believe there is still an issue when using source maps and a minified output.

sass --style=compressed --sourcemaps=file style.scss compiled.css

This creates a single line output. However convert_urls will rewrite this file making the generated source map inaccurate. It would be better to first convert the urls and then apply the compiler. This however requires the creation of a temporary file, which then gets altered and then compiled. Nasty, but maybe the only way to do it.

A solution could look like this:

    def convert_urls_to_tempfile(full_source_path, source_path):
        '''read the content of source_path, appy transformation to it, save it as a temporary and return path to that file'''
        _, tmp_path = tempfile.mkstemp(dir=os.path.dirname(full_source_path))
        with open(tmp_path, 'wb') as tmp_file:
            with open(full_source_path, 'rb') as source_file:
            tmp_file.write(
                url_converter.convert(source_file.read(),
                    source_path)

        return tmp_path


    def compile_file(self, source_path):
        full_source_path = self.get_full_source_path(source_path)
        full_output_path = self.get_full_output_path(source_path)
        full_output_dirname = os.path.dirname(full_output_path)

        content_path = copy_content_to_tempfile(full_source_path, source_path)

        try:
            args = [
                self.executable,
                "--sourcemap=none",
            ]

            if self.is_compass_enabled:
                args.append("--compass")

            args.extend([
                content_path,
                full_output_path,
            ])

            if not os.path.exists(full_output_dirname):
                os.makedirs(full_output_dirname)

            # `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)

            if errors:
                if os.path.exists(full_output_path):
                    os.remove(full_output_path)
                raise exceptions.StaticCompilationError(errors)

        finally:
            os.remove(content_path)

        return self.get_output_path(source_path)

[andreyfedoseev]

I believe there is still an issue when using source maps and a minified output.

SCSSCompiler doesn't produce minified output, so I think that's not the case.

[jaheba]

It certainly can once people demand smaller generated css files (--style=compressed).

Maybe, lets just leave this as a reminder for what could possibly go "wrong".

[andreyfedoseev]

Support for source maps was added in 1.1