/// <summary>
/// Processes the specified bundle of LESS files.
/// </summary>
/// <param name="context"> </param>
/// <param name="bundle">The LESS bundle.</param>
public void Process(BundleContext context, BundleResponse bundle)
{
if (bundle == null)
throw new ArgumentNullException("bundle");
context.HttpContext.Response.Cache.SetLastModifiedFromFileDependencies();
var parser = new Parser();
var engine = new LessEngine(parser);
var content = new StringBuilder();
foreach (var file in bundle.Files)
{
// set current file path
SetCurrentFilePath(parser, file.FullName);
var text = File.ReadAllText(file.FullName);
var css = engine.TransformToCss(text, file.FullName);
content.AppendLine(css);
// content.Append(engine.TransformToCss(text, file.FullName));
// content.AppendLine();
AddFileDependencies(parser);
}
bundle.Content = content.ToString();
bundle.ContentType = "text/css";
}
public static CompileResult CompileLess(string file, string contents, string theme, Dictionary<string, string> themeLessVariables)
{
if (string.IsNullOrEmpty(theme))
theme = "Default";
var importedFilePaths = new HashSet<string>();
var logger = new ThemedLessLogger(theme);
var engine = new LessEngine(
new Parser(new ConsoleStylizer(), new Importer(importedFilePaths, file, theme)),
logger, false, false)
{
Plugins = new List<IPluginConfigurator>
{
new VariableOverridePluginConfigurator(themeLessVariables)
}
};
if (string.IsNullOrEmpty(contents))
{
using (var sr = new StreamReader(System.Web.Hosting.HostingEnvironment.VirtualPathProvider.GetFile(file).Open()))
{
contents = sr.ReadToEnd();
}
}
var result = engine.TransformToCss(contents, file);
if (logger.LoggedErrors.Any())
{
throw new Exception("Error(s) compiling less. " +
string.Join(" - ", logger.LoggedErrors.Select(x => "\"" + x + "\"").ToArray()));
}
return new CompileResult(result, importedFilePaths);
}
private ILessEngine GetEngine()
{
var importer = new Importer(new CustomFileReader(fileSystem, filePath));
var parser = new Parser(new PlainStylizer(), importer);
var engine = new LessEngine(parser) { Compress = true };
return engine;
}
ILessEngine CreateLessEngine(string path)
{
var importer = new Importer(new MulderFileReader(fileSystem, path));
var parser = new Parser(new PlainStylizer(), importer);
var engine = new LessEngine(parser) { Compress = true };
return engine;
}
private ILessEngine GetEngine()
{
var importer = new Importer(new FileReader(new CustomPathResolver(filePath)));
var parser = new Parser(new PlainStylizer(), importer);
var engine = new LessEngine(parser);
return engine;
}
private ILessEngine GetLessEngine(string physicalPath)
{
var basePath = Path.GetDirectoryName(physicalPath);
var stylizer = new PlainStylizer();
var importer = new Importer(new FileReader(new BasePathResolver(basePath)));
var parser = new Parser(stylizer, importer) { NodeProvider = new RawUrlNodeProvider() };
var lessEngine = new LessEngine(parser);
return lessEngine;
}
public static string Generate(string fileName, string less, string color1, string color2)
{
var reader = new CustomFileReader(color1, color2);
var importer = new Importer(reader);
var parser = new Parser(new PlainStylizer(), importer, false);
var lessEngine = new LessEngine(parser, NullLogger.Instance, true, false);
less = Regex.Replace(less, "\\.theme-color\\(([a-z-]+),? ?", Evaluate);
lessEngine.CurrentDirectory = Path.GetDirectoryName(fileName);
return lessEngine.TransformToCss(less, Path.GetFileName(fileName));
}
public ILessEngine GetEngine(IFileSystem fileSystem, string directory)
{
IStylizer stylizer = new HtmlStylizer();
IPathResolver pathResolver = new TestPathResolver(directory);
IFileReader reader = new TestFileReader(fileSystem, pathResolver);
var importer = new Importer(reader);
var parser = new Parser(stylizer, importer);
ILogger logger = new ConsoleLogger(LogLevel.Error);
var engine = new LessEngine(parser, logger, true);
engine.Compress = true;
return engine;
}
protected override string ReadFileContent(string fileSystemPath, bool minify)
{
var directory = Path.GetDirectoryName(fileSystemPath);
var pathResolver = new AbsolutePathResolver(directory);
var fileReader = new FileReader { PathResolver = pathResolver };
var importer = new Importer { FileReader = fileReader };
var parser = new Parser { Importer = importer };
var lessEngine = new LessEngine { Parser = parser };
var rawFileContent = base.ReadFileContent(fileSystemPath, false);
return lessEngine.TransformToCss(rawFileContent, fileSystemPath);
}
public static CompileResult CompileLess(string file, string contents = null, string theme = null)
{
var importedFilePaths = new HashSet<string>();
var engine = new LessEngine(new Parser(new ConsoleStylizer(), new Importer(importedFilePaths, file, theme)));
if (string.IsNullOrEmpty(contents))
{
using (var sr = new StreamReader(System.Web.Hosting.HostingEnvironment.VirtualPathProvider.GetFile(file).Open()))
{
contents = sr.ReadToEnd();
}
}
var result = engine.TransformToCss(contents, file);
return new CompileResult(result, importedFilePaths);
}
public void Process(BundleContext context, BundleResponse response)
{
var engine = new LessEngine() { Logger = new ExceptionLogger() };
var output = new StringBuilder();
foreach (var file in response.Files)
{
var content = File.ReadAllText(file.FullName);
content = ResolveImportPaths(content, context.HttpContext);
var css = engine.TransformToCss(content, null);
output.Append(css);
}
response.ContentType = "text/css";
response.Content = output.ToString();
}
public CompileResult Compile(string source, CompileContext context)
{
var sourceFile = context.RootDirectory.GetFile(context.SourceFilePath);
importedFilePaths = new HashedSet<string>();
var parser = new Parser
{
Importer = new Importer(new CassetteLessFileReader(sourceFile.Directory, importedFilePaths))
};
var errorLogger = new ErrorLogger();
var engine = new LessEngine(
parser,
errorLogger,
configuration.MinifyOutput,
configuration.Debug,
configuration.DisableVariableRedefines,
configuration.DisableColorCompression,
configuration.KeepFirstSpecialComment,
configuration.Plugins);
string css;
try
{
css = engine.TransformToCss(source, sourceFile.FullPath);
}
catch (Exception ex)
{
throw new LessCompileException(
string.Format("Error compiling {0}{1}{2}", context.SourceFilePath, Environment.NewLine, ex.Message),
ex
);
}
if (errorLogger.HasErrors)
{
var exceptionMessage = string.Format(
"Error compiling {0}{1}{2}",
context.SourceFilePath,
Environment.NewLine,
errorLogger.ErrorMessage
);
throw new LessCompileException(exceptionMessage);
}
else
{
return new CompileResult(css, importedFilePaths);
}
}
public ParseResult ParseFile(string appRelativePath)
{
var physicalPath = GetFullPath(appRelativePath);
using (new CurrentDirectoryWrapper(Path.GetDirectoryName(physicalPath)))
{
var engine = new LessEngine();
return
new ParseResult
{
// Note, the order here is important
Content = engine.TransformToCss(fileReader.GetFileContents(appRelativePath), appRelativePath),
FileDependencies = new[] { physicalPath }.Concat(engine.GetImports().Select(x => GetImportPath(appRelativePath, x)))
};
}
}
public string Compile(string source, IFile sourceFile)
{
var parser = new Parser
{
Importer = new Importer(new CassetteLessFileReader(sourceFile.Directory))
};
var errorLogger = new ErrorLogger();
var engine = new LessEngine(parser, errorLogger, false);
var css = engine.TransformToCss(source, sourceFile.FullPath);
if (errorLogger.HasErrors)
{
throw new LessCompileException(errorLogger.ErrorMessage);
}
else
{
return css;
}
}
/// <summary>
/// Transforms the content of the given string from Less into CSS.
/// </summary>
/// <param name="input">The input string to transform.</param>
/// <param name="path">The path to the given input string to transform.</param>
/// <param name="cruncher">The cruncher that is running the transform.</param>
/// <returns>The transformed string.</returns>
public string Transform(string input, string path, CruncherBase cruncher)
{
// The standard engine returns a FileNotFoundExecption so I've rolled my own path resolver.
Parser parser = new Parser();
DotLessPathResolver dotLessPathResolver = new DotLessPathResolver(path);
FileReader fileReader = new FileReader(dotLessPathResolver);
parser.Importer = new Importer(fileReader);
ILessEngine lessEngine = new LessEngine(parser);
try
{
string result = lessEngine.TransformToCss(input, path);
if (cruncher.Options.CacheFiles)
{
// Add each import as a file dependency so that the cache will clean itself.
IEnumerable<string> imports = lessEngine.GetImports();
IList<string> enumerable = imports as IList<string> ?? imports.ToList();
if (enumerable.Any())
{
foreach (string import in enumerable)
{
if (!import.Contains(Uri.SchemeDelimiter))
{
string filePath =
HostingEnvironment.MapPath(VirtualPathUtility.Combine(dotLessPathResolver.CurrentFileDirectory, import));
cruncher.AddFileMonitor(filePath, "not empty");
}
}
}
}
return result;
}
catch (Exception ex)
{
throw new LessCompilingException(ex.Message, ex.InnerException);
}
}
public string Preprocess(string data, string fileName)
{
// Ensure that the current directory for the @import statements
// is the directory of the file.
var fullFilePath = Path.Combine(this.appPath, fileName.Replace('/', '\\'));
Directory.SetCurrentDirectory(Path.GetDirectoryName(fullFilePath));
// Execute LESS engine but do not compress or optimize. This allows resolving
// @import statements during debugging as well as a pretty-print version of the CSS.
// However, when not debugging, all of the statements should be resolved in the Process()
// method. This is because statements like `filter: progid:DXImageTransform...` can't be parsed
// if they've been preprocessed to regular CSS.
if (this.debugState.IsDebugging())
{
var e = new LessEngine(new dotless.Core.Parser.Parser(optimization: 0), new IgniteDotLessLogger(), compress: false);
return e.TransformToCss(data, fileName);
}
else
{
return data;
}
}
/// <summary>
/// Transforms some LESS source code (and any related files) to CSS.
/// </summary>
/// <param name="source">The LESS code to transform.</param>
/// <param name="file">The context file system.</param>
public string Compile(string source, IFile file)
{
var parser = new Parser {Importer = new Importer(new LessFileReader(file.Directory))};
var engine = new LessEngine(parser, _logger, false, false);
string css = null;
try
{
css = engine.TransformToCss(source, file.Name);
}
catch (FileNotFoundException ex)
{
_logger.Error("The file you are trying to import '{0}' cannot be found.".FormatWith(ex.FileName));
}
if (_logger.HasErrors)
throw new LessCompileException(_logger.ErrorMessage);
return css;
}
/// <summary>
///
/// </summary>
/// <param name="inPath"></param>
/// <param name="outPath"></param>
public CompileResults Compile(string inPath, string outPath)
{
using (StreamReader sr = new StreamReader(inPath))
{
LessEngine engine = new LessEngine();
SetCurrentFilePath(engine.Parser, inPath);
var fileReader = new FileReader();
var source = fileReader.GetFileContents(inPath);
var output = engine.TransformToCss(source, inPath);
if (engine.LastTransformationSuccessful)
{
using (StreamWriter sw = new StreamWriter(outPath))
{
sw.WriteLine(OrangeBits.GetHeader(inPath));
sw.Write(output);
}
}
else
{
throw new Exception("Error compiling LESS");
}
}
return null;
}
public string TransformContent(ResourceSet resourceSet, Resource resource, string content)
{
var engine = new LessEngine(new Parser(new ConsoleStylizer(), new Importer(new AdeptFileReader(resource.Path))));
return engine.TransformToCss(content, resource.Path);
}
/// <summary>
/// Gets the file dependencies (@imports) of the LESS file being parsed.
/// </summary>
/// <param name="lessEngine">The LESS engine.</param>
/// <returns>An array of file references to the dependent file references.</returns>
private static IEnumerable<BundleFile> GetFileDependencies(LessEngine lessEngine)
{
ImportedFilePathResolver pathResolver = lessEngine.Parser.GetPathResolver();
VirtualPathProvider vpp = BundleTable.VirtualPathProvider;
foreach (string resolvedVirtualPath in lessEngine.GetImports().Select(pathResolver.GetFullPath))
{
// the file was successfully imported, therefore no need to check before vpp.GetFile
yield return new BundleFile(resolvedVirtualPath, vpp.GetFile(resolvedVirtualPath));
}
lessEngine.ResetImports();
}
public void TestMethod1()
{
string rootPath = @"C:\Users\justbe\Dropbox\Code\OrangeBits\Demo\";
string inPath = rootPath + @"importTest.less";
string outPath = rootPath + @"importTest.css";
LessEngine engine = new LessEngine();
SetCurrentFilePath(engine.Parser, inPath);
var fileReader = new FileReader();
var source = fileReader.GetFileContents(inPath);
var css = engine.TransformToCss(source, inPath);
}
public DotLessCompiler()
{
_engine = new LessEngine();
}
public string Transform(string source)
{
var engine = new LessEngine(new Parser(), new WeirdLogger(LogLevel.Warn), false, false);
return engine.TransformToCss(source, null);
}
