def find_dependencies(self, source_path):
source = self.get_source(source_path)
source_dir = posixpath.dirname(source_path)
dependencies = set()
imported_files = set()
for import_path in self.find_imports(source):
if import_path.endswith(".styl"):
# @import "foo.styl"
imported_files.add(
self.locate_imported_file(source_dir, import_path))
elif import_path.endswith("/*"):
# @import "foo/*"
imported_dir = posixpath.join(source_dir, import_path[:-2])
try:
imported_dir_full_path = self.get_full_source_path(
imported_dir)
except ValueError:
raise exceptions.StaticCompilationError(
"Can't locate the imported directory: {0}".format(
import_path))
if not os.path.isdir(imported_dir_full_path):
raise exceptions.StaticCompilationError(
"Imported path is not a directory: {0}".format(
import_path))
for filename in os.listdir(imported_dir_full_path):
if filename.endswith(".styl"):
imported_files.add(
self.locate_imported_file(imported_dir, filename))
else:
try:
# @import "foo" -> @import "foo/index.styl"
imported_dir = posixpath.join(source_dir, import_path)
imported_dir_full_path = self.get_full_source_path(
imported_dir)
if os.path.isdir(imported_dir_full_path):
imported_files.add(
self.locate_imported_file(imported_dir,
"index.styl"))
except ValueError:
# @import "foo" -> @import "foo.styl"
imported_files.add(
self.locate_imported_file(source_dir,
import_path + ".styl"))
dependencies.update(imported_files)
for imported_file in imported_files:
dependencies.update(self.find_dependencies(imported_file))
return sorted(dependencies)
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)
args = [
self.executable,
"--sourcemap={}".format("auto" if self.is_sourcemap_enabled else "none"),
] + self.get_extra_args()
args.extend([
self.get_full_source_path(source_path),
full_output_path,
])
full_output_dirname = os.path.dirname(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("/")))))
return_code, out, errors = utils.run_command(args, None, cwd=cwd)
if return_code:
if os.path.exists(full_output_path):
os.remove(full_output_path)
raise exceptions.StaticCompilationError(errors)
utils.convert_urls(full_output_path, source_path)
if self.is_sourcemap_enabled:
utils.fix_sourcemap(full_output_path + ".map", source_path, full_output_path)
return self.get_output_path(source_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)
args = [
self.executable,
]
if self.is_sourcemap_enabled:
args.append("-m")
args.extend([
full_source_path,
"-o",
os.path.dirname(full_output_path),
])
full_output_dirname = os.path.dirname(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, cwd=cwd)
if errors:
raise exceptions.StaticCompilationError(errors)
utils.convert_urls(full_output_path, source_path)
if self.is_sourcemap_enabled:
utils.fix_sourcemap(full_output_path + ".map", source_path,
full_output_path)
return self.get_output_path(source_path)
def compile_file(self, source_path):
args = [
self.executable,
] + self.get_extra_args()
if self.is_sourcemap_enabled:
args.append("-s")
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:
utils.fix_sourcemap(full_output_path + ".map", source_path, full_output_path)
return self.get_output_path(source_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)
# `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("/")))))
args = [self.executable]
if self.is_sourcemap_enabled:
args.extend(["--source-map"])
if self.global_vars:
for variable_name, variable_value in self.global_vars.items():
args.extend([
"--global-var={}={}".format(variable_name, variable_value),
])
args.extend([
self.get_full_source_path(source_path),
full_output_path,
])
return_code, out, errors = utils.run_command(args, cwd=cwd)
if return_code:
raise exceptions.StaticCompilationError(errors)
utils.convert_urls(full_output_path, source_path)
if self.is_sourcemap_enabled:
utils.fix_sourcemap(full_output_path + ".map", source_path,
full_output_path)
return self.get_output_path(source_path)
def compile_file(self, source_path):
full_output_path = self.get_full_output_path(source_path)
# LiveScript bug with source map if the folder isn't already present
if not os.path.exists(os.path.dirname(full_output_path)):
os.makedirs(os.path.dirname(full_output_path))
args = [
self.executable,
"-c",
]
if self.is_sourcemap_enabled:
args.append("-m")
args.append("linked")
args.extend([
"-o",
os.path.dirname(full_output_path),
self.get_full_source_path(source_path),
])
return_code, out, errors = utils.run_command(args)
if return_code:
raise exceptions.StaticCompilationError(errors)
if self.is_sourcemap_enabled:
utils.fix_sourcemap(full_output_path + ".map", source_path,
full_output_path)
return self.get_output_path(source_path)
def compile_file(self, source_path):
full_output_path = self.get_full_output_path(source_path)
output_dir = os.path.dirname(full_output_path)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
template_extension = os.path.splitext(source_path)[1].lstrip(".")
args = [
self.executable,
self.get_full_source_path(source_path),
"-e",
template_extension,
"-f",
full_output_path,
] + self.get_extra_args()
if self.is_sourcemap_enabled:
args += ["--map", full_output_path + ".map"]
out, errors = utils.run_command(args)
if errors:
raise exceptions.StaticCompilationError(errors)
if self.is_sourcemap_enabled:
utils.fix_sourcemap(full_output_path + ".map", source_path,
full_output_path)
return self.get_output_path(source_path)
def compile_file(self, source_path):
full_output_path = self.get_full_output_path(source_path)
args = [
self.executable,
"-c",
]
if self.is_sourcemap_enabled:
args.append("-m")
if self.transpile:
args.append("-t")
if not self.header:
args.append("--no-header")
args.extend([
"-o",
os.path.dirname(full_output_path),
self.get_full_source_path(source_path),
])
return_code, out, errors = utils.run_command(args)
if return_code:
raise exceptions.StaticCompilationError(errors)
if self.is_sourcemap_enabled:
utils.fix_sourcemap(
os.path.splitext(full_output_path)[0] + ".map", source_path,
full_output_path)
return self.get_output_path(source_path)
def compile_file(self, source_path):
full_output_path = self.get_full_output_path(source_path)
args = [self.executable]
args.append("{}:{}".format(self.get_full_source_path(source_path),
full_output_path))
return_code, out, errors = utils.run_command(args)
if return_code:
raise exceptions.StaticCompilationError(errors)
if self.compress:
args = [
'google-closure-compiler', '--compilation_level=SIMPLE',
'--js=' + full_output_path,
'--create_source_map=' + full_output_path + '.map',
'--assume_function_wrapper'
]
return_code, out, errors = utils.run_command(args)
with open(full_output_path, 'w') as file:
file.write(out)
return self.get_output_path(source_path)
def compile_source(self, source):
try:
compiled = sass.compile(string=source, indented=self.indented)
except sass.CompileError as e:
raise exceptions.StaticCompilationError(encoding.force_str(e))
compiled = encoding.force_str(compiled)
return compiled
def compile_source(self, source):
args = [self.executable, "-"]
return_code, out, errors = utils.run_command(args, source)
if return_code:
raise exceptions.StaticCompilationError(errors)
return out
def compile_source(self, source):
args = [
self.executable,
] + self.get_extra_args()
out, errors = utils.run_command(args, source)
if errors:
raise exceptions.StaticCompilationError(errors)
return out
def compile_source(self, source):
args = [self.executable, "-"]
if self.include_path:
args.extend(["--include-path={}".format(self.include_path)])
return_code, out, errors = utils.run_command(args, source)
if return_code:
raise exceptions.StaticCompilationError(errors)
return out
def compile_source(self, source):
args = [
self.executable,
"-p",
]
out, errors = utils.run_command(args, input=source)
if errors:
raise exceptions.StaticCompilationError(errors)
return out
def compile_source(self, source):
args = [self.executable]
if self.modules is not None:
args.extend(["--modules", self.modules])
out, errors = utils.run_command(args, source)
if errors:
raise exceptions.StaticCompilationError(errors)
return out
def locate_imported_file(self, source_dir, import_path):
""" Locate the imported file in the source directory.
Return the path to the imported file relative to STATIC_ROOT
:param source_dir: source directory
:type source_dir: str
:param import_path: path to the imported file
:type import_path: str
:returns: str
"""
import_filename = posixpath.basename(import_path)
import_dirname = posixpath.dirname(import_path)
import_filename_root, import_filename_extension = posixpath.splitext(
import_filename)
if import_filename_extension:
filenames_to_try = [import_filename]
else:
# No extension is specified for the imported file, try all supported extensions
filenames_to_try = [
import_filename_root + "." + extension
for extension in self.import_extensions
]
if not import_filename.startswith("_"):
# Try the files with "_" prefix
filenames_to_try += [
"_" + filename for filename in filenames_to_try
]
# Try to locate the file in the directory relative to `source_dir`
for filename in filenames_to_try:
source_path = posixpath.normpath(
posixpath.join(source_dir, import_dirname, filename))
try:
self.get_full_source_path(source_path)
return source_path
except ValueError:
pass
# Try to locate the file in the directories listed in `load_paths`
for dirname in self.load_paths:
for filename in filenames_to_try:
source_path = posixpath.join(import_dirname, filename)
if os.path.exists(
os.path.join(dirname,
utils.normalize_path(source_path))):
return source_path
raise exceptions.StaticCompilationError(
"Can't locate the imported file: {0}".format(import_path))
def compile_source(self, source):
args = [
self.executable,
"-s",
]
if self.executable.endswith("scss"):
args.append("--sass")
out, errors = utils.run_command(args, source)
if errors:
raise exceptions.StaticCompilationError(errors)
return out
def compile_source(self, source):
args = [
self.executable,
"-s",
] + self.get_extra_args()
if self.executable.endswith("sass"):
args.append("--scss")
return_code, out, errors = utils.run_command(args, source)
if return_code:
raise exceptions.StaticCompilationError(errors)
return out
def compile_source(self, source):
args = [
self.executable,
"-c",
"-s",
"-p",
]
if self.transpile:
args.append("-t")
if not self.header:
args.append("--no-header")
return_code, out, errors = utils.run_command(args, source)
if return_code:
raise exceptions.StaticCompilationError(errors)
return out
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)
if not os.path.exists(full_output_dirname):
os.makedirs(full_output_dirname)
sourcemap_path = full_output_path + ".map"
sourcemap = ""
try:
if self.is_sourcemap_enabled:
compiled, sourcemap = sass.compile(
filename=full_source_path,
source_map_filename=sourcemap_path,
include_paths=self.load_paths
)
else:
compile_kwargs = {}
if self.load_paths:
compile_kwargs["include_paths"] = self.load_paths
if self.precision:
compile_kwargs["precision"] = self.precision
if self.output_style:
compile_kwargs["output_style"] = self.output_style
compiled = sass.compile(filename=full_source_path, **compile_kwargs)
except sass.CompileError as e:
raise exceptions.StaticCompilationError(encoding.force_str(e))
compiled = encoding.force_str(compiled)
sourcemap = encoding.force_str(sourcemap)
with open(full_output_path, "w+") as output_file:
output_file.write(compiled)
utils.convert_urls(full_output_path, source_path)
if self.is_sourcemap_enabled:
with open(sourcemap_path, "w+") as output_file:
output_file.write(sourcemap)
utils.fix_sourcemap(sourcemap_path, source_path, full_output_path)
return self.get_output_path(source_path)
def compile_file(self, 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 locate_imported_file(self, source_dir, import_path):
""" Locate the imported file in the source directory.
Return the path to the imported file relative to STATIC_ROOT
:param source_dir: source directory
:type source_dir: str
:param import_path: path to the imported file
:type import_path: str
:returns: str
"""
path = posixpath.normpath(posixpath.join(source_dir, import_path))
try:
self.get_full_source_path(path)
except ValueError:
raise exceptions.StaticCompilationError(
"Can't locate the imported file: {0}".format(import_path))
return 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)
# `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("/")))))
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)
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 locate_imported_file(self, source_dir, import_path):
""" Locate the imported file in the source directory.
Return the path to the imported file relative to STATIC_ROOT
:param source_dir: source directory
:type source_dir: str
:param import_path: path to the imported file
:type import_path: str
:returns: str
"""
for extension in self.import_extensions:
import_path_probe = import_path
if not import_path_probe.endswith("." + extension):
import_path_probe += "." + extension
path = posixpath.normpath(
posixpath.join(source_dir, import_path_probe))
try:
self.get_full_source_path(path)
return path
except ValueError:
pass
filename = posixpath.basename(import_path_probe)
if filename[0] != "_":
path = posixpath.normpath(
posixpath.join(
source_dir,
posixpath.dirname(import_path_probe),
"_" + filename,
))
try:
self.get_full_source_path(path)
return path
except ValueError:
pass
raise exceptions.StaticCompilationError(
"Can't locate the imported file: {0}".format(import_path))
def compile_file(self, 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):
raise exceptions.StaticCompilationError(
"This is currently not supported")
