private string BuildSassFile(string inputFilePath, string outputFilePath, string sourceMapFilePath, bool buildSourceMap = false)
{
try
{
var options = new CompilationOptions
{
SourceMap = buildSourceMap
};
var result = SassCompiler.CompileFile(inputFilePath, outputFilePath, sourceMapFilePath, options);
_fileService.SaveFile(outputFilePath, result.CompiledContent);
if (buildSourceMap && sourceMapFilePath.HasValue())
{
_fileService.SaveFile(sourceMapFilePath, result.SourceMap);
}
}
catch (SassCompilationException ex)
{
var errorDetails = SassErrorHelpers.GenerateErrorDetails(ex);
_logger.Error <SassService>(ex, errorDetails);
return(ex.Message);
}
return(string.Empty);
}
public void CompileFile(bool withFileManager)
{
SetFileManager(withFileManager);
Document document = s_documents[DocumentName];
string compiledContent = SassCompiler.CompileFile(document.AbsolutePath).CompiledContent;
}
async Task CompileFilesAsync(IEnumerable <string> sassFiles)
{
foreach (var file in sassFiles)
{
var fileInfo = new FileInfo(file);
if (fileInfo.Name.StartsWith("_"))
{
WriteVerbose($"Skipping: {fileInfo.FullName}");
continue;
}
WriteVerbose($"Processing: {fileInfo.FullName}");
var result = SassCompiler.CompileFile(file, options: Options.SassCompilationOptions);
var newFile = fileInfo.FullName.Replace(fileInfo.Extension, ".css");
if (File.Exists(newFile) && result.CompiledContent == await File.ReadAllTextAsync(newFile))
{
continue;
}
await File.WriteAllTextAsync(newFile, result.CompiledContent);
}
}
public virtual void MappingSyntaxErrorDuringCompilationOfFileIsCorrect()
{
// Arrange
string inputFilePath = Path.Combine(_filesDirectoryPath,
string.Format("invalid-syntax/{0}/style{1}", _subfolderName, _fileExtension));
SassСompilationException exception = null;
// Act
try
{
CompilationResult result = SassCompiler.CompileFile(inputFilePath);
}
catch (SassСompilationException e)
{
exception = e;
}
// Assert
Assert.NotNull(exception);
Assert.NotEmpty(exception.Message);
Assert.Equal(GetCanonicalPath(inputFilePath), exception.File);
Assert.Equal(3, exception.LineNumber);
Assert.Equal(13, exception.ColumnNumber);
}
public virtual void FileWithImportCompilationIsCorrect()
{
// Arrange
string inputFilePath = Path.Combine(_filesDirectoryPath,
string.Format("import/{0}/base{1}", _subfolderName, _fileExtension));
string importedFilePath = Path.Combine(_filesDirectoryPath,
string.Format("import/{0}/_reset{1}", _subfolderName, _fileExtension));
string outputFilePath = Path.Combine(_filesDirectoryPath, "import/base.css");
string targetOutputCode = File.ReadAllText(outputFilePath);
var options = new CompilationOptions
{
SourceMap = true
};
// Act
CompilationResult result = SassCompiler.CompileFile(inputFilePath, options: options);
// Assert
Assert.Equal(targetOutputCode, result.CompiledContent);
Assert.False(string.IsNullOrEmpty(result.SourceMap));
var includedFilePaths = result.IncludedFilePaths;
Assert.Equal(2, includedFilePaths.Count);
Assert.Equal(GetCanonicalPath(inputFilePath), includedFilePaths[0]);
Assert.Equal(GetCanonicalPath(importedFilePath), includedFilePaths[1]);
}
public virtual void MappingFileNotFoundErrorDuringCompilationOfFileIsCorrect()
{
// Arrange
string inputFilePath = Path.Combine(_filesDirectoryPath,
string.Format("non-existing-files/{0}/style{1}", _subfolderName, _fileExtension));
SassCompilationException exception = null;
// Act
try
{
CompilationResult result = SassCompiler.CompileFile(inputFilePath);
}
catch (SassCompilationException e)
{
exception = e;
}
// Assert
Assert.NotNull(exception);
Assert.NotEmpty(exception.Message);
Assert.Null(exception.File);
Assert.Equal(-1, exception.LineNumber);
Assert.Equal(-1, exception.ColumnNumber);
}
public void ShouldNotCompileFileWithEchoOutputStyle()
{
// Arrange
// Act
Action compile = () => SassCompiler.CompileFile(BasicPath, OutputStyle.Echo);
// Assert
compile.ShouldThrow <ArgumentException>();
}
protected override string Update()
{
try {
var options = new CompilationOptions {
SourceMap = true
};
options.OutputStyle = OutputStyle.Compact;
options.SourceMapFileUrls = true;
//options.IncludePaths = new string[] { Path.Combine(Path.GetDirectoryName(InputFilePath), "Dependencies\\Csml\\Fonts") };
SassCompiler.FileManager = this;// new FileManager(Path.GetDirectoryName(InputFilePath), LibSassHost.FileManager.Instance);
CompilationResult result = SassCompiler.CompileFile(InitialFilePath, null, null, options);
if (DeveloperMode)
{
observableFiles = CaptureModificationTimes(result.IncludedFilePaths);
}
//OutputFileName = "style.css";
var outputMapFileName = "style.css.map";
if (!DeveloperMode)
{
var hash = Hash.CreateFromString(result.CompiledContent).ToString();
OutputFileName = hash + ".css";
outputMapFileName = OutputFileName + ".map";
}
string outputFilePath = Path.Combine(OutputRootDirectory, OutputFileName);
string sourceMapFilePath = Path.Combine(OutputRootDirectory, outputMapFileName);
File.WriteAllText(outputFilePath, result.CompiledContent);
File.WriteAllText(sourceMapFilePath, result.SourceMap);
} catch (SassCompilationException e) {
if (e.File != null)
{
if (!observableFiles.ContainsKey(e.File))
{
observableFiles.Add(e.File, File.GetLastWriteTime(e.File));
}
}
var files = observableFiles.Select(x => x.Key).ToArray();
observableFiles = CaptureModificationTimes(files);
if (!DeveloperMode)
{
throw e;
}
return(e.Message);
}
return(null);
}
public void ShouldCompileFileWithoutComments()
{
// Arrange
const string expectedResult = "body .class {\n color: red; }\n";
// Act
string compiled = SassCompiler.CompileFile(BasicPath, sourceComments: false);
// Assert
compiled.Should().BeEquivalentTo(expectedResult);
}
public void ShouldCompileFileWithCompressedOutputStyle()
{
// Arrange
const string expectedResult = "body .class {color:red;}";
// Act
string compiled = SassCompiler.CompileFile(BasicPath, OutputStyle.Compressed);
// Assert
compiled.Should().BeEquivalentTo(expectedResult);
}
public void CompilationOfFileWithAppAbsolutePaths()
{
// Arrange
var virtualFileManagerMock = new Mock <IFileManager>();
virtualFileManagerMock
.SetupGet(fm => fm.SupportsVirtualPaths)
.Returns(true)
;
virtualFileManagerMock
.Setup(fm => fm.GetCurrentDirectory())
.Returns("/")
;
virtualFileManagerMock
.Setup(fm => fm.FileExists(It.IsAny <string>()))
.Returns((string p) => {
if (p == _siteInputFileAbsolutePath)
{
return(true);
}
return(_siteImportedFiles.ContainsKey(p));
})
;
virtualFileManagerMock
.Setup(fm => fm.ReadFile(It.IsAny <string>()))
.Returns((string p) => {
if (p == _siteInputFileAbsolutePath)
{
return(_siteInputFileContent);
}
return(_siteImportedFiles[p]);
})
;
IFileManager virtualFileManager = new VirtualFileManager(virtualFileManagerMock);
var options = new CompilationOptions {
SourceMap = true
};
// Act
CompilationResult result;
using (var compiler = new SassCompiler(virtualFileManager))
{
result = compiler.CompileFile(_siteInputFileAbsolutePath, options: options);
}
// Assert
Assert.AreEqual(_siteOutputFileContent, result.CompiledContent);
Assert.AreEqual(_siteIncludedFilePaths, result.IncludedFilePaths);
Assert.AreEqual(_siteSourceMapFileContent, result.SourceMap);
}
public void ShouldCompileFile()
{
// Arrange
string expectedResult = String.Format("/* line 3, {0} */\nbody .class {{\n color: red; }}\n", BasicPath);
// Act
string compiled = SassCompiler.CompileFile(BasicPath);
// Assert
compiled.Should().BeEquivalentTo(expectedResult);
}
public void ShouldCompileFileWithImport()
{
// Arrange
string expectedResult = String.Format("/* line 1, {0} */\nbody {{\n border-color: green; }}\n\n/* line 5, {1} */\nbody .class {{\n color: red; }}\n", ReplaceLastSlash(ImportPath), ImportingPath);
// Act
string compiled = SassCompiler.CompileFile(ImportingPath);
// Assert
compiled.Should().BeEquivalentTo(expectedResult);
}
public void Compile()
{
Document document = Documents[DocumentName];
var options = new CompilationOptions {
SourceMap = true
};
using (var compiler = new SassCompiler(options))
{
CompilationResult result = compiler.CompileFile(document.AbsolutePath);
}
}
//[Produces("text/css")]
//[Consumes("text/css")]
public ContentResult SassConverter(string fileName)
{
var fullFilePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "sass", $"{fileName}.scss");
var result = SassCompiler.CompileFile(fullFilePath, options: new CompilationOptions
{
SourceMap = false,
OutputStyle = OutputStyle.Compact,
SourceComments = false,
});
//Response.ContentType = "text/css";
return(Content(result.CompiledContent, "text/css"));
//return result.CompiledContent;
}
public void SimpleFile() => UseTempFolder(folder =>
{
var input = ".a { .b { margin: 0; } .c { margin: 1px; } }";
var expected = ".a .b{margin:0}.a .c{margin:1px}\n";
var mainScss = Path.Combine(folder, "main.scss");
File.WriteAllText(mainScss, input, new UTF8Encoding(false));
var compiler = new SassCompiler();
var res = compiler.CompileFile(mainScss, new SassOptions(
outputStyle: SassOutputStyle.Compressed,
indent: string.Empty,
sourceMapEmbed: false
));
Assert.Equal(expected, res.Css);
});
public void ShouldCompileFileWithAdditionalImport()
{
// Arrange
string expectedResult = String.Format("/* line 1, {0} */\nbody {{\n border-color: green; }}\n\n/* line 3, {1} */\nbody > #id {{\n font-size: 14px; }}\n\n/* line 6, {2} */\nbody .class {{\n color: red; }}\n",
ReplaceLastSlash(ImportPath),
ReplaceLastSlash(AdditionalImportPath),
ImportingAdditionalPath);
// Act
string compiled = SassCompiler.CompileFile(ImportingAdditionalPath, additionalIncludePaths: new[]
{
AdditionalImportTestFilesDirectory
});
// Assert
compiled.Should().BeEquivalentTo(expectedResult);
}
public void CompilationOfFileWithAppRelativePaths()
{
var virtualFileManagerMock = new Mock <IFileManager>();
virtualFileManagerMock
.SetupGet(fm => fm.SupportsVirtualPaths)
.Returns(true)
;
virtualFileManagerMock
.Setup(fm => fm.GetCurrentDirectory())
.Returns(_appAbsolutePath)
;
virtualFileManagerMock
.Setup(fm => fm.FileExists(_appInputFileRelativePath))
.Returns(true)
;
virtualFileManagerMock
.Setup(fm => fm.FileExists(_appInputFileAbsolutePath))
.Returns(true)
;
virtualFileManagerMock
.Setup(fm => fm.ReadFile(_appInputFileAbsolutePath))
.Returns(_appInputFileContent)
;
IFileManager virtualFileManager = new VirtualFileManager(virtualFileManagerMock, _appAbsolutePath);
var options = new CompilationOptions {
SourceMap = true
};
// Act
CompilationResult result;
using (var compiler = new SassCompiler(virtualFileManager))
{
result = compiler.CompileFile(_appInputFileRelativePath, options: options);
}
// Assert
Assert.AreEqual(_appOutputFileContent, result.CompiledContent);
Assert.AreEqual(1, result.IncludedFilePaths.Count);
Assert.AreEqual(_appInputFileAbsolutePath, result.IncludedFilePaths[0]);
Assert.AreEqual(_appSourceMapFileContent, result.SourceMap);
}
protected static void CompileContent()
{
try
{
var options = new CompilationOptions {
SourceMap = true, OutputStyle = OutputStyle.Compressed, SourceMapFileUrls = true
};
CompilationResult compilationResult = SassCompiler.CompileFile(ImportingPath, OutputhPath, OutputhmapPath, options);
Console.WriteLine("Compiled content:{1}{1}{0}{1}", compilationResult.CompiledContent,
Environment.NewLine);
Console.WriteLine("Source map:{1}{1}{0}{1}", compilationResult.SourceMap, Environment.NewLine);
Console.WriteLine("Included file paths: {0}",
string.Join(", ", compilationResult.IncludedFilePaths));
}
catch (SassСompilationException ex)
{
Console.WriteLine(SassErrorHelpers.Format(ex));
}
}
static void Main(string[] args)
{
UseTempFolder(folder =>
{
var input = "@import './import';\n.a { .b { margin: 0; } }";
var imported = ".a { .c { margin: 1px; } }";
var mainScss = Path.Combine(folder, "main.scss");
var importScss = Path.Combine(folder, "_import.scss");
File.WriteAllText(mainScss, input, new UTF8Encoding(false));
File.WriteAllText(importScss, imported, new UTF8Encoding(false));
var compiler = new SassCompiler();
var res = compiler.CompileFile(mainScss, new SassOptions(
outputStyle: SassOutputStyle.Compressed,
indent: string.Empty,
sourceMapEmbed: false
));
Console.WriteLine(res.Css);
});
}
public ActionResult SaveStyles(string color, string font)
{
//Set the sass variables from the input field
string scssString = @"$mainColor:" + color + ";$mainFont:" + font + ";";
//Write the new variables to the custom variables scss file
System.IO.File.WriteAllText(Server.MapPath("~/Content/scss/_variablesCustom.scss"), scssString);
//Initiate a new sass compiler
ISassCompiler sassCompiler = new SassCompiler();
//Compile the styles.scss sass file
string sassOutput = sassCompiler.CompileFile(Server.MapPath("~/Content/scss/styles.scss"), OutputStyle.Compressed, sourceComments: false);
//And write the compiled output to the styles.css file, the one included on your page
System.IO.File.WriteAllText(Server.MapPath("~/Content/styles.css"), sassOutput);
return(RedirectToAction("Index"));
}
protected static void CompileFile()
{
WriteHeader("Compilation of SCSS file");
string inputFilePath = Path.Combine(_filesDirectoryPath, "style.scss");
string outputFilePath = Path.Combine(_filesDirectoryPath, "style.css");
try
{
var options = new CompilationOptions {
SourceMap = true, SourceMapFileUrls = true
};
CompilationResult result = SassCompiler.CompileFile(inputFilePath, outputFilePath, options: options);
WriteOutput(result);
}
catch (SassException e)
{
WriteError("During compilation of SCSS file an error occurred.", e);
}
}
static void Process(int jobID)
{
Console.WriteLine("Start JobID: {0}...", jobID);
var sw = new Stopwatch();
sw.Start();
SassCompiler compiler = new SassCompiler();
{
//var result = compiler.CompileFile(Path.Combine(srcpath, @"..\..\bootstrap.scss"), includeSourceComments: false );
var result = compiler.CompileFile(@"default.scss", OutputStyle.Nested, "http://winfly/", false, 5, true, null);
File.WriteAllText(String.Format(@"{0}\foundation-libsass{1}.css", OutputDir, jobID), result.CSS);
}
sw.Stop();
Console.WriteLine("JobID: {0} Took: {1}.", jobID, sw.ElapsedMilliseconds);
}
public virtual void FileWithUtf8CharactersCompilationIsCorrect()
{
// Arrange
string inputFilePath = Path.Combine(_filesDirectoryPath,
string.Format("ютф-8/{0}/символы{1}", _subfolderName, _fileExtension));
string outputFilePath = Path.Combine(_filesDirectoryPath, "ютф-8/символы.css");
string targetOutputCode = File.ReadAllText(outputFilePath);
// Act
CompilationResult result = SassCompiler.CompileFile(inputFilePath);
// Assert
Assert.Equal(targetOutputCode, result.CompiledContent);
Assert.True(string.IsNullOrEmpty(result.SourceMap));
var includedFilePaths = result.IncludedFilePaths;
Assert.Equal(1, includedFilePaths.Count);
Assert.Equal(GetCanonicalPath(inputFilePath), includedFilePaths[0]);
}
protected static void CompileFile()
{
WriteHeader("Compilation of SCSS file");
string inputFilePath = Path.Combine(_filesDirectoryPath, "style.scss");
string outputFilePath = Path.Combine(_filesDirectoryPath, "style.css");
try
{
using (var sassCompiler = new SassCompiler(new CompilationOptions {
SourceMap = true
}))
{
CompilationResult result = sassCompiler.CompileFile(inputFilePath, outputFilePath);
WriteVersion(sassCompiler.Version);
WriteOutput(result);
}
}
catch (SassException e)
{
WriteError("During compilation of SCSS file an error occurred.", e);
}
}
public override Task Invoke(IOwinContext context)
{
var path = FileSystem.MapPath(_options.BasePath, context.Request.Path.Value);
var ext = Path.GetExtension(path);
if (ExtToHandle(ext))
{
Trace.WriteLine("Invoke SassMiddleware");
context.Response.StatusCode = 200;
context.Response.ContentType = MimeTypeService.GetMimeType(".css");
var compiler = new SassCompiler();
var compressed = compiler.CompileFile(path, OutputStyle.Compressed, false);
compressed = compressed.Replace(";}", "}").Replace(" {", "{");
context.Response.Write(compressed);
return(Globals.CompletedTask);
}
return(Next.Invoke(context));
}
static async Task CompileFilesAsync(IEnumerable <string> sassFiles)
{
foreach (var file in sassFiles)
{
var fileInfo = new FileInfo(file);
if (fileInfo.Name.StartsWith("_"))
{
continue;
}
var result = SassCompiler.CompileFile(file, options: new CompilationOptions {
OutputStyle = OutputStyle.Compressed
});
var newFile = fileInfo.FullName.Replace(fileInfo.Extension, ".css");
if (File.Exists(newFile) && result.CompiledContent == await File.ReadAllTextAsync(newFile))
{
continue;
}
await File.WriteAllTextAsync(newFile, result.CompiledContent);
}
}
public virtual void FileWithImportCompilationIsCorrect()
{
// Arrange
string inputFilePath = Path.Combine(_resourcesDirectoryPath,
string.Format("import/{0}/base{1}", _subfolderName, _fileExtension));
string importedFilePath = Path.Combine(_resourcesDirectoryPath,
string.Format("import/{0}/_reset{1}", _subfolderName, _fileExtension));
string outputFilePath = Path.Combine(_resourcesDirectoryPath, "import/base.css");
string targetOutputCode = File.ReadAllText(outputFilePath);
var options = new CompilationOptions
{
SourceMap = true
};
// Act
CompilationResult result;
using (var compiler = new SassCompiler())
{
result = compiler.CompileFile(inputFilePath, options: options);
}
// Assert
Assert.Equal(targetOutputCode, result.CompiledContent);
Assert.False(string.IsNullOrEmpty(result.SourceMap));
var includedFilePaths = result.IncludedFilePaths;
Assert.Equal(2, includedFilePaths.Count);
Assert.Equal(GetCanonicalPath(inputFilePath), includedFilePaths[0]);
Assert.Equal(GetCanonicalPath(importedFilePath), includedFilePaths[1]);
}
public virtual void FileWithUnicodeCharactersCompilationIsCorrect()
{
// Arrange
string inputFilePath = Path.Combine(_resourcesDirectoryPath,
string.Format("юникод/{0}/символы{1}", _subfolderName, _fileExtension));
string outputFilePath = Path.Combine(_resourcesDirectoryPath, "юникод/символы.css");
string targetOutputCode = File.ReadAllText(outputFilePath);
// Act
CompilationResult result;
using (var compiler = new SassCompiler())
{
result = compiler.CompileFile(inputFilePath);
}
// Assert
Assert.Equal(targetOutputCode, result.CompiledContent);
Assert.True(string.IsNullOrEmpty(result.SourceMap));
var includedFilePaths = result.IncludedFilePaths;
Assert.Equal(1, includedFilePaths.Count);
Assert.Equal(GetCanonicalPath(inputFilePath), includedFilePaths[0]);
}