public void Process(BundleContext context, BundleResponse response)
{
if (response == null)
{
throw new ArgumentNullException("response");
}
context.HttpContext.Response.Cache.SetLastModifiedFromFileDependencies();
var lessParser = new Parser();
ILessEngine lessEngine = CreateLessEngine(lessParser);
foreach (FileInfo fileInfo in response.Files)
{
SetCurrentFilePath(lessParser, fileInfo.FullName);
var source = File.ReadAllText(fileInfo.FullName);
var result = lessEngine.TransformToCss(source, fileInfo.FullName);
// NOTE: HttpContext.Items is used instead of BundleResponse.Content
// to pass processed files
context.HttpContext.Items.Add(fileInfo.FullName, result);
AddFileDependencies(lessParser);
}
}
/// <inheritdoc />
public IEnumerable <IDocument> Execute(IReadOnlyList <IDocument> inputs, IExecutionContext context)
{
DotlessConfiguration config = DotlessConfiguration.GetDefault();
config.Logger = typeof(LessLogger);
EngineFactory engineFactory = new EngineFactory(config);
FileSystemReader fileSystemReader = new FileSystemReader(context.FileSystem);
return(inputs.AsParallel().Select(context, input =>
{
Trace.Verbose("Processing Less for {0}", input.SourceString());
ILessEngine engine = engineFactory.GetEngine();
// TODO: Get rid of RefelectionMagic and this ugly hack as soon as dotless gets better external DI support
engine.AsDynamic().Underlying.Cache = new LessCache(context.ExecutionCache);
engine.AsDynamic().Underlying.Underlying.Parser.Importer.FileReader = fileSystemReader;
FilePath path = input.FilePath(Keys.RelativeFilePath);
string fileName = null;
if (path != null)
{
engine.CurrentDirectory = path.Directory.FullPath;
fileName = path.FileName.FullPath;
}
else
{
engine.CurrentDirectory = string.Empty;
fileName = Path.GetRandomFileName();
}
string content = engine.TransformToCss(input.Content, fileName);
return context.GetDocument(input, content);
}));
}
private static IEnumerable<string> Compile(ILessEngine engine, string inputFilePath, string outputFilePath)
{
Console.Write("Compiling {0} -> {1} ", inputFilePath, outputFilePath);
try
{
var source = new FileReader().GetFileContents(inputFilePath);
var css = engine.TransformToCss(source, inputFilePath);
File.WriteAllText(outputFilePath, css);
Console.WriteLine("[Done]");
return new[] { inputFilePath }.Concat(engine.GetImports());
}
catch(IOException)
{
throw;
}
catch (Exception ex)
{
Console.WriteLine("[FAILED]");
Console.WriteLine("Compilation failed: {0}", ex.Message);
Console.WriteLine(ex.StackTrace);
return null;
}
}
public HandlerImpl(IRequest request, IResponse response, ILessEngine engine, ILessSource lessSource)
{
this.request = request;
this.response = response;
this.engine = engine;
this.lessSource = lessSource;
}
public IEnumerable <IDocument> Execute(IReadOnlyList <IDocument> inputs, IExecutionContext context)
{
DotlessConfiguration config = DotlessConfiguration.GetDefault();
config.Logger = typeof(LessLogger);
EngineFactory engineFactory = new EngineFactory(config);
return(inputs.AsParallel().Select(x =>
{
context.Trace.Verbose("Processing Less for {0}", x.Source);
ILessEngine engine = engineFactory.GetEngine();
// TODO: Get rid of RefelectionMagic and this ugly hack as soon as dotless gets better external DI support
engine.AsDynamic().Underlying.Cache = new LessCache(context.ExecutionCache);
string path = x.Get <string>(Keys.SourceFilePath, null);
string fileName = null;
if (path != null)
{
engine.CurrentDirectory = Path.GetDirectoryName(path);
fileName = Path.GetFileName(path);
}
else
{
engine.CurrentDirectory = context.InputFolder;
fileName = Path.GetRandomFileName();
}
string content = engine.TransformToCss(x.Content, fileName);
return x.Clone(content);
}));
}
public void Process(BundleContext context, BundleResponse bundle)
{
if (bundle == null)
{
throw new ArgumentNullException("bundle");
}
context.HttpContext.Response.Cache.SetLastModifiedFromFileDependencies();
var lessParser = new Parser();
ILessEngine lessEngine = CreateLessEngine(lessParser);
var content = new StringBuilder(bundle.Content.Length);
foreach (FileInfo file in bundle.Files)
{
SetCurrentFilePath(lessParser, file.FullName);
string source = File.ReadAllText(file.FullName);
content.Append(lessEngine.TransformToCss(source, file.FullName));
content.AppendLine();
AddFileDependencies(lessParser);
}
bundle.ContentType = "text/css";
bundle.Content = content.ToString();
}
/// <summary>
/// Un-decorates <see cref="LessEngine" /> from <paramref name="engine" />. Can process only
/// <see cref="CacheDecorator" /> and <see cref="ParameterDecorator" />, otherwise raises exception.
/// </summary>
/// <param name="engine">Possibly decorated <see cref="ILessEngine" /></param>
/// <exception cref="ArgumentException">Unexpected type of <paramref name="engine" /></exception>
/// <returns><see cref="LessEngine" /> instance.</returns>
internal static LessEngine ResolveLessEngine(this ILessEngine engine)
{
if (engine == null)
{
throw new ArgumentNullException("engine");
}
while (true)
{
var lessEngine = engine as LessEngine;
if (lessEngine != null)
{
return(lessEngine);
}
var cacheDecorator = engine as CacheDecorator;
if (cacheDecorator != null)
{
engine = cacheDecorator.Underlying;
}
else
{
var parameterDecorator = engine as ParameterDecorator;
if (parameterDecorator == null)
{
throw new ArgumentException(string.Format("Cannot resolve {0} to LessEngine", engine.GetType()));
}
engine = parameterDecorator.Underlying;
}
}
}
public LessHandlerImpl(IHttp http, IResponse response, ILessEngine engine, IFileReader fileReader)
{
Http = http;
Response = response;
Engine = engine;
FileReader = fileReader;
}
public HandlerImpl(IHttp http, IResponse response, ILessEngine engine, IFileReader fileReader)
{
Http = http;
Response = response;
Engine = engine;
FileReader = fileReader;
}
public LessHandler(IFileWrapper fileWrapper)
{
this.fileWrapper = fileWrapper;
var config = new DotlessConfiguration
{
CacheEnabled = false,
Logger = typeof(LessLogger),
Web = HttpContext.Current != null,
};
if (HttpContext.Current == null)
{
engine = new EngineFactory(config).GetEngine();
}
else
{
var dotLessAssembly = Assembly.GetAssembly(typeof(ContainerFactory));
var factoryType = dotLessAssembly.GetType("dotless.Core.AspNetContainerFactory");
var fac = (ContainerFactory)(factoryType.InvokeMember("", BindingFlags.CreateInstance, null, null, null));
var locator = factoryType.InvokeMember("GetContainer", BindingFlags.InvokeMethod, null, fac, new object[] { config });
engine =
(ILessEngine)
(dotLessAssembly.GetType("Microsoft.Practices.ServiceLocation.IServiceLocator").InvokeMember(
"GetInstance", BindingFlags.InvokeMethod, null, locator, new object[] { typeof(ILessEngine) }));
}
}
public void SetUp()
{
request = MockRepository.GenerateStub<IRequest>();
response = MockRepository.GenerateStub<IResponse>();
engine = MockRepository.GenerateStub<ILessEngine>();
lessSource = MockRepository.GenerateStub<ILessSource>();
}
private static string TransformCss(Parser lessParser, FileInfo bundleFile, ILessEngine lessEngine)
{
SetCurrentFilePath(lessParser, bundleFile.FullName);
string source = File.ReadAllText(bundleFile.FullName);
string css = lessEngine.TransformToCss(source, bundleFile.FullName);
return(css);
}
private static IEnumerable <string> CompileImpl(ILessEngine engine, string inputFilePath, string outputFilePath)
{
engine = new FixImportPathDecorator(engine);
var currentDir = Directory.GetCurrentDirectory();
try
{
Console.WriteLine("{0} -> {1}", inputFilePath, outputFilePath);
var directoryPath = Path.GetDirectoryName(inputFilePath);
var fileReader = new dotless.Core.Input.FileReader();
var source = fileReader.GetFileContents(inputFilePath);
Directory.SetCurrentDirectory(directoryPath);
var css = engine.TransformToCss(source, inputFilePath);
File.WriteAllText(outputFilePath, css);
if (!engine.LastTransformationSuccessful)
{
returnCode = -5;
Console.WriteLine();
Console.WriteLine("[Done - Failed]");
}
else
{
Console.WriteLine("[Done]");
}
var files = new List <string>();
files.Add(inputFilePath);
foreach (var file in engine.GetImports())
{
files.Add(Path.Combine(directoryPath, Path.GetExtension(file)));
}
engine.ResetImports();
return(files);
}
catch (IOException ex)
{
Console.WriteLine("[FAILED]");
Console.WriteLine("Compilation failed: {0}", ex.Message);
Console.WriteLine(ex.StackTrace);
returnCode = -2;
return(null);
}
catch (Exception ex)
{
Console.WriteLine("[FAILED]");
Console.WriteLine("Compilation failed: {0}", ex.Message);
Console.WriteLine(ex.StackTrace);
returnCode = -3;
return(null);
}
finally
{
Directory.SetCurrentDirectory(currentDir);
}
}
private static CompilationDelegate CreationImpl(ILessEngine engine, string inputFilePath, string outputDirectoryPath)
{
var pathbuilder = new System.Text.StringBuilder(outputDirectoryPath + Path.DirectorySeparatorChar);
pathbuilder.Append(Path.ChangeExtension(Path.GetFileName(inputFilePath), "css"));
var outputFilePath = Path.GetFullPath(pathbuilder.ToString());
return(() => CompileImpl(engine, inputFilePath, outputFilePath));
}
public Task <LessCompilationResult> CompileAsync(string content, PathString virtualPathPrefix, string filePath, IFileProvider fileProvider, PathString outputPath, CancellationToken token)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
token.ThrowIfCancellationRequested();
string fileBasePath, fileName;
if (filePath != null)
{
filePath = UrlUtils.NormalizePath(filePath.Replace('\\', '/'));
fileName = UrlUtils.GetFileNameSegment(filePath, out StringSegment basePathSegment).Value;
basePathSegment = UrlUtils.NormalizePathSegment(basePathSegment, trailingNormalization: PathNormalization.ExcludeSlash);
fileBasePath = basePathSegment.Value;
}
else
{
fileBasePath = "/";
fileName = string.Empty;
}
ILessEngine engine = _engineFactory.Create(fileBasePath, virtualPathPrefix, fileProvider, outputPath, token);
Exception transformException = null;
try { content = engine.TransformToCss(content, fileName); }
catch (FileNotFoundException ex) { transformException = ex; }
if (transformException != null || !engine.LastTransformationSuccessful)
{
if (transformException == null && engine is LessEngine lessEngine)
{
transformException = lessEngine.LastTransformationError;
}
filePath = filePath ?? "(content)";
const string messageFormat = "Less compilation of '{0}' failed.";
_logger.LogError(string.Format(messageFormat, "{FILEPATH}") + Environment.NewLine + "{REASON}", filePath, transformException?.Message ?? "Unknown reason.");
throw new BundlingErrorException(string.Format(messageFormat, filePath), transformException);
}
return(Task.FromResult(new LessCompilationResult(content, engine.GetImports().Select(path => UrlUtils.NormalizePath(path, canonicalize: true)).ToArray())));
}
public LessHandler(IFileWrapper fileWrapper)
{
this.fileWrapper = fileWrapper;
var config = new DotlessConfiguration
{
CacheEnabled = false,
Logger = typeof(LessLogger),
Web = HttpContext.Current != null,
};
var engineFactory = new EngineFactory(config);
if (HttpContext.Current == null)
engine = engineFactory.GetEngine();
else
engine = engineFactory.GetEngine(new AspNetContainerFactory());
}
public void Process(BundleContext context, BundleResponse bundle)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (bundle == null)
{
throw new ArgumentNullException("bundle");
}
context.HttpContext.Response.Cache.SetLastModifiedFromFileDependencies();
var lessParser = new Parser();
ILessEngine lessEngine = CreateLessEngine(lessParser);
var content = new StringBuilder(bundle.Content.Length);
var bundleFiles = new List <BundleFile>();
foreach (var bundleFile in bundle.Files)
{
bundleFiles.Add(bundleFile);
var name = context.HttpContext.Server.MapPath(bundleFile.VirtualFile.VirtualPath);
SetCurrentFilePath(lessParser, name);
using (var stream = bundleFile.VirtualFile.Open())
using (var reader = new StreamReader(stream))
{
string source = reader.ReadToEnd();
content.Append(lessEngine.TransformToCss(source, name));
content.AppendLine();
}
bundleFiles.AddRange(GetFileDependencies(lessParser));
}
if (BundleTable.EnableOptimizations)
{
// include imports in bundle files to register cache dependencies
bundle.Files = bundleFiles.Distinct();
}
bundle.ContentType = "text/css";
bundle.Content = content.ToString();
}
/// <summary>
/// Attempts to compile a less file into css.
/// </summary>
/// <param name="engine">The dotless engine.</param>
/// <param name="inputFilePath">The input less file.</param>
/// <param name="outputFilePath">The output css file.</param>
/// <returns>The return code. 0 is success; otherwise, value is failure.</returns>
private int CompileImpl(ILessEngine engine, string inputFilePath, string outputFilePath)
{
engine = new FixImportPathDecorator(engine);
var currentDir = Directory.GetCurrentDirectory();
try
{
Log.LogMessage("Compiling less from \"{0}\" to \"{1}\".", inputFilePath, outputFilePath);
var directoryPath = Path.GetDirectoryName(inputFilePath);
var fileReader = new dotless.Core.Input.FileReader();
var source = fileReader.GetFileContents(inputFilePath);
Directory.SetCurrentDirectory(directoryPath);
var css = engine.TransformToCss(source, inputFilePath);
File.WriteAllText(outputFilePath, css);
if (!engine.LastTransformationSuccessful)
{
Log.LogError("Failed: Compiling less from \"{0}\" to \"{1}\".", inputFilePath, outputFilePath);
return(-5);
}
else
{
Log.LogMessage("Success: Compiled less from \"{0}\" to \"{1}\".", inputFilePath, outputFilePath);
}
var files = new List <string>();
files.Add(inputFilePath);
foreach (var file in engine.GetImports())
{
files.Add(Path.Combine(directoryPath, Path.ChangeExtension(file, "less")));
}
engine.ResetImports();
return(0);
}
catch (Exception ex)
{
Log.LogError("Failed: Compiling less from \"{0}\" to \"{1}\".", inputFilePath, outputFilePath);
Log.LogError("Compilation failed: {0}", ex.ToString());
return(-3);
}
finally
{
Directory.SetCurrentDirectory(currentDir);
}
}
private static void RunBenchmark(string[] files, Dictionary <string, string> contents, int rounds, Func <string, ILessEngine, int> runTest)
{
var engines = new ILessEngine[]
{
new LessEngine()
};
Console.Write(" File | Size |");
foreach (var engine in engines)
{
Console.Write(engine.GetType().Name.PadRight(24).PadLeft(29));
Console.Write('|');
}
Console.WriteLine();
Console.WriteLine(new string('-', 35 + 30 * engines.Length));
foreach (var file in files)
{
var size = rounds * contents[file].Length / 1024d;
Console.Write("{0} | {1,8:#,##0.00} Kb | ", file.PadRight(18), size);
var times = new List <double>();
foreach (var engine in engines)
{
try
{
var time = runTest(file, engine) / 1000d;
times.Add(time);
Console.Write("{0,8:#.00} s {1,10:#,##0.00} Kb/s | ", time, size / time);
}
catch
{
Console.Write("Failed | ");
}
}
if (times.Count == 2)
{
Console.Write("{0,4:0.#}x", times[0] / times[1]);
}
Console.WriteLine();
}
Console.WriteLine("Done. Press 'r' to repeat or any key to exit");
}
/// <summary>
///
/// </summary>
/// <param name="LessCode"></param>
/// <returns></returns>
async static protected Task<string> TransformAsync(string LessCode, string FileName = "unknown.less")
{
return await TaskEx.RunPropagatingExceptionsAsync(() =>
{
if (Config == null)
{
Config = new DotlessConfiguration()
{
MinifyOutput = true,
};
}
if (Engine == null)
{
Engine = new EngineFactory(Config).GetEngine();
}
return Engine.TransformToCss(LessCode, FileName);
});
}
/// <inheritdoc />
public IEnumerable <IDocument> Execute(IReadOnlyList <IDocument> inputs, IExecutionContext context)
{
DotlessConfiguration config = DotlessConfiguration.GetDefault();
config.Logger = typeof(LessLogger);
EngineFactory engineFactory = new EngineFactory(config);
FileSystemReader fileSystemReader = new FileSystemReader(context.FileSystem);
return(inputs.AsParallel().Select(context, input =>
{
Trace.Verbose("Processing Less for {0}", input.SourceString());
ILessEngine engine = engineFactory.GetEngine();
// TODO: Get rid of RefelectionMagic and this ugly hack as soon as dotless gets better external DI support
engine.AsDynamic().Underlying.Cache = new LessCache(context.ExecutionCache);
engine.AsDynamic().Underlying.Underlying.Parser.Importer.FileReader = fileSystemReader;
// Less conversion
FilePath path = _inputPath.Invoke <FilePath>(input, context);
if (path != null)
{
engine.CurrentDirectory = path.Directory.FullPath;
}
else
{
engine.CurrentDirectory = string.Empty;
path = new FilePath(Path.GetRandomFileName());
Trace.Warning($"No input path found for document {input.SourceString()}, using {path.FileName.FullPath}");
}
string content = engine.TransformToCss(input.Content, path.FileName.FullPath);
// Process the result
FilePath cssPath = path.ChangeExtension("css");
return context.GetDocument(
input,
context.GetContentStream(content),
new MetadataItems
{
{ Keys.RelativeFilePath, cssPath },
{ Keys.WritePath, cssPath }
});
}));
}
public LessHandler(IFileWrapper fileWrapper)
{
this.fileWrapper = fileWrapper;
var config = new DotlessConfiguration
{
CacheEnabled = false,
Logger = typeof(LessLogger),
Web = HttpContext.Current != null,
};
var engineFactory = new EngineFactory(config);
if (HttpContext.Current == null)
{
engine = engineFactory.GetEngine();
}
else
{
engine = engineFactory.GetEngine(new AspNetContainerFactory());
}
}
public Task <LessCompilationResult> CompileAsync(string content, string virtualPathPrefix, string filePath, IFileProvider fileProvider, CancellationToken token)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
token.ThrowIfCancellationRequested();
string fileBasePath, virtualBasePath, fileName;
if (filePath != null)
{
fileBasePath = Path.GetDirectoryName(filePath).Replace('\\', '/');
virtualBasePath = new PathString(virtualPathPrefix).Add(fileBasePath);
fileName = Path.GetFileName(filePath);
}
else
{
fileBasePath = virtualBasePath = fileName = null;
}
ILessEngine engine = _engineFactory.Create(fileBasePath ?? string.Empty, virtualBasePath ?? string.Empty, fileProvider);
content = engine.TransformToCss(content, fileName);
if (!engine.LastTransformationSuccessful)
{
_logger.LogWarning($"Less compilation of '{{FILEPATH}}' failed:{Environment.NewLine}{{REASON}}",
(filePath ?? "(content)"),
(engine is LessEngine lessEngine ? lessEngine.LastTransformationError?.Message : null) ?? "Unknown reason.");
content = null;
}
return(Task.FromResult(
content != null ?
new LessCompilationResult(content, engine.GetImports().ToArray()) :
LessCompilationResult.Failure));
}
private static IEnumerable <string> CompileImpl(ILessEngine engine, string inputFilePath, string outputFilePath)
{
var currentDir = Directory.GetCurrentDirectory();
try
{
Console.WriteLine("{0} -> {1}", inputFilePath, outputFilePath);
var directoryPath = Path.GetDirectoryName(inputFilePath);
var source = new dotless.Core.Input.FileReader().GetFileContents(inputFilePath);
Directory.SetCurrentDirectory(directoryPath);
var css = engine.TransformToCss(source, inputFilePath);
File.WriteAllText(outputFilePath, css);
Console.WriteLine("[Done]");
var files = new List <string>();
files.Add(inputFilePath);
foreach (var file in engine.GetImports())
{
files.Add(Path.Combine(directoryPath, Path.ChangeExtension(file, "less")));
}
engine.ResetImports();
return(files);
}
catch (IOException)
{
throw;
}
catch (Exception ex)
{
Console.WriteLine("[FAILED]");
Console.WriteLine("Compilation failed: {0}", ex.Message);
Console.WriteLine(ex.StackTrace);
return(null);
}
finally
{
Directory.SetCurrentDirectory(currentDir);
}
}
public void ProcessRequest(HttpContext context)
{
var request = context.Request;
var response = context.Response;
var user = context.User;
string assetUrl = request.Url.LocalPath;
string assetPath = context.Server.MapPath(assetUrl);
//load less file into the data.
var data = "";
using (var file = new StreamReader(assetPath))
{
data = file.ReadToEnd();
}
DotlessConfiguration lessEngineConfig = DotlessConfiguration.GetDefault();
lessEngineConfig.MapPathsToWeb = false;
lessEngineConfig.CacheEnabled = false;
lessEngineConfig.DisableUrlRewriting = false;
lessEngineConfig.Web = false;
lessEngineConfig.MinifyOutput = true;
lessEngineConfig.LessSource = typeof(VirtualFileReader);
var lessEngineFactory = new EngineFactory(lessEngineConfig);
ILessEngine lessEngine = lessEngineFactory.GetEngine();
string vars = "";
//TODO set default for vars
if (user != null)
{
//TODO get vars for user
}
var content = lessEngine.TransformToCss(string.Format("{0}{1}", vars, data), null);
// Output text content of asset
response.ContentType = "text/css";
response.Write(content);
response.End();
}
public LessHandler(IFileWrapper fileWrapper)
{
this.fileWrapper = fileWrapper;
var config = new DotlessConfiguration
{
CacheEnabled = false,
Logger = typeof(LessLogger),
Web = HttpContext.Current != null,
};
if (HttpContext.Current == null)
engine = new EngineFactory(config).GetEngine();
else
{
var dotLessAssembly = Assembly.GetAssembly(typeof (ContainerFactory));
var factoryType = dotLessAssembly.GetType("dotless.Core.AspNetContainerFactory");
var fac = (ContainerFactory)(factoryType.InvokeMember("", BindingFlags.CreateInstance, null, null, null));
var locator = factoryType.InvokeMember("GetContainer", BindingFlags.InvokeMethod, null, fac, new object[] {config});
engine =
(ILessEngine)
(dotLessAssembly.GetType("Microsoft.Practices.ServiceLocation.IServiceLocator").InvokeMember(
"GetInstance", BindingFlags.InvokeMethod, null, locator, new object[] {typeof (ILessEngine)}));
}
}
private static IEnumerable<string> CompileImpl(ILessEngine engine, string inputFilePath, string outputFilePath)
{
engine = new FixImportPathDecorator(engine);
var currentDir = Directory.GetCurrentDirectory();
try
{
Console.WriteLine("{0} -> {1}", inputFilePath, outputFilePath);
var directoryPath = Path.GetDirectoryName(inputFilePath);
var source = new dotless.Core.Input.FileReader().GetFileContents(inputFilePath);
Directory.SetCurrentDirectory(directoryPath);
var css = engine.TransformToCss(source, inputFilePath);
File.WriteAllText(outputFilePath, css);
Console.WriteLine("[Done]");
var files = new List<string>();
files.Add(inputFilePath);
foreach (var file in engine.GetImports())
files.Add(Path.Combine(directoryPath, Path.ChangeExtension(file, "less")));
engine.ResetImports();
return files;
}
catch (IOException)
{
throw;
}
catch (Exception ex)
{
Console.WriteLine("[FAILED]");
Console.WriteLine("Compilation failed: {0}", ex.Message);
Console.WriteLine(ex.StackTrace);
return null;
}
finally
{
Directory.SetCurrentDirectory(currentDir);
}
}
public SourceTransformation Transform(IEnumerable <FileInfo> files)
{
var lessParser = new Parser();
ILessEngine lessEngine = CreateLessEngine(lessParser);
var bundleFiles = new List <FileInfo>();
var content = new StringBuilder();
foreach (FileInfo bundleFile in files)
{
bundleFiles.Add(bundleFile);
string css = TransformCss(lessParser, bundleFile, lessEngine);
content.AppendFormat("{0}\n", css);
bundleFiles.AddRange(GetFileDependencies(lessParser));
}
return(new SourceTransformation
{
Dependencies = bundleFiles,
Source = content.ToString()
});
}
public LessCompiler(ILessEngine engine)
{
_engine = engine;
}
public FixImportPathDecorator(ILessEngine underlying)
{
this.underlying = underlying;
}
public static string Parse(ILessEngine engine, string less, DotlessConfiguration config)
{
return(engine.TransformToCss(less, null));
}
public static void Main(string[] args)
{
Directory.SetCurrentDirectory(@"C:\dev\oss\less.js\test\less");
var files = new[]
{
"colors",
"comments",
"css",
"css-3",
"mixins",
"mixins-args",
"operations",
"parens",
"rulesets",
"scope",
"selectors",
"strings",
"variables",
"whitespace"
}
.Select(f => f + ".less");
var contents = files
.ToDictionary(f => f, f => new LessSourceObject { Content = File.ReadAllText(f) });
const int rounds = 150;
Func<string, ILessEngine, int> runTest =
(file, engine) => Enumerable
.Range(0, rounds)
.Select(i =>
{
var starttime = DateTime.Now;
engine.TransformToCss(contents[file]);
var duration = (DateTime.Now - starttime);
return duration.Milliseconds;
})
.Sum();
Console.WriteLine("Press Enter to begin benchmark");
Console.ReadLine();
Console.WriteLine("Running each test {0} times\n", rounds);
var engines = new ILessEngine[]
{
new ExtensibleEngine(),
new LessJsEngine()
};
Console.Write(" File | Size |");
foreach (var engine in engines)
{
Console.Write(engine.GetType().Name.PadRight(24).PadLeft(29));
Console.Write('|');
}
Console.WriteLine();
Console.WriteLine(new string('-', 35 + 30*engines.Length));
foreach (var file in files)
{
var size = rounds*contents[file].Content.Length/1024d;
Console.Write("{0} | {1,8:#,##0.00} Kb | ", file.PadRight(18), size);
foreach (var engine in engines)
{
try
{
var time = runTest(file, engine)/1000d;
Console.Write("{0,8:#.00} s {1,10:#,##0.00} Kb/s | ", time, size/time);
}
catch
{
Console.Write("Failied | ");
}
}
Console.WriteLine();
}
// Console.Read();
}
public LessCompiler(ILessEngine lessEngine)
{
this.lessEngine = lessEngine;
}
/// <summary>
/// Attempts to compile a less file into css.
/// </summary>
/// <param name="engine">The dotless engine.</param>
/// <param name="inputFilePath">The input less file.</param>
/// <param name="outputFilePath">The output css file.</param>
/// <returns>The return code. 0 is success; otherwise, value is failure.</returns>
private int CompileImpl(ILessEngine engine, string inputFilePath, string outputFilePath)
{
engine = new FixImportPathDecorator(engine);
var currentDir = Directory.GetCurrentDirectory();
try
{
Log.LogMessage("Compiling less from \"{0}\" to \"{1}\".", inputFilePath, outputFilePath);
var directoryPath = Path.GetDirectoryName(inputFilePath);
var fileReader = new dotless.Core.Input.FileReader();
var source = fileReader.GetFileContents(inputFilePath);
Directory.SetCurrentDirectory(directoryPath);
var css = engine.TransformToCss(source, inputFilePath);
File.WriteAllText(outputFilePath, css);
if (!engine.LastTransformationSuccessful)
{
Log.LogError("Failed: Compiling less from \"{0}\" to \"{1}\".", inputFilePath, outputFilePath);
return -5;
}
else
{
Log.LogMessage("Success: Compiled less from \"{0}\" to \"{1}\".", inputFilePath, outputFilePath);
}
var files = new List<string>();
files.Add(inputFilePath);
foreach (var file in engine.GetImports())
files.Add(Path.Combine(directoryPath, Path.ChangeExtension(file, "less")));
engine.ResetImports();
return 0;
}
catch (Exception ex)
{
Log.LogError("Failed: Compiling less from \"{0}\" to \"{1}\".", inputFilePath, outputFilePath);
Log.LogError("Compilation failed: {0}", ex.ToString());
return -3;
}
finally
{
Directory.SetCurrentDirectory(currentDir);
}
}
internal static string Process(ref IEnumerable <BundleFile> files)
{
DotlessConfiguration lessConfig = new WebConfigConfigurationLoader().GetConfiguration();
if (!lessConfig.LessSource.GetInterfaces().Contains(typeof(IFileReaderWithResolver)))
{
lessConfig.LessSource = typeof(LessVirtualFileReader);
}
// system.Web.Optimization cache is used instead
lessConfig.CacheEnabled = false;
var content = new StringBuilder();
var targetFiles = new List <BundleFile>();
foreach (BundleFile bundleFile in files)
{
// initialize the less engine once for each file.
// this is to prevent leaking state between files
ILessEngine lessEngine = LessWeb.GetEngine(lessConfig);
LessEngine underlyingLessEngine = lessEngine.ResolveLessEngine();
Parser lessParser = underlyingLessEngine.Parser;
targetFiles.Add(bundleFile);
string filePath = bundleFile.IncludedVirtualPath;
filePath = filePath.Replace('\\', '/');
filePath = VirtualPathUtility.ToAppRelative(filePath);
lessParser.SetCurrentFilePath(filePath);
string source = bundleFile.ApplyTransforms();
string extension = VirtualPathUtility.GetExtension(filePath);
// if plain CSS file, do not transform LESS
if (lessConfig.ImportAllFilesAsLess ||
".less".Equals(extension, StringComparison.InvariantCultureIgnoreCase) ||
".less.css".Equals(extension, StringComparison.InvariantCultureIgnoreCase))
{
string lessOutput = lessEngine.TransformToCss(source, filePath);
// pass the transformation result if successful
if (lessEngine.LastTransformationSuccessful)
{
source = lessOutput;
}
else
{
// otherwise write out error message.
// the transformation error is logged in LessEngine.TransformToCss
if (lessConfig.Debug)
{
content.AppendLine(string.Format(
"/* Error occurred in LESS transformation of the file: {0}. Please see details in the dotless log */",
bundleFile.IncludedVirtualPath));
}
continue;
}
}
source = ConvertUrlsToAbsolute(bundleFile.IncludedVirtualPath, source);
content.AppendLine(source);
BundleFile[] fileDependencies = GetFileDependencies(underlyingLessEngine).ToArray();
targetFiles.AddRange(fileDependencies);
DependencyCache.SaveFileDependencies(filePath, fileDependencies.Select(file => file.IncludedVirtualPath).ToArray());
}
// include imports in bundle files to register cache dependencies
files = BundleTable.EnableOptimizations ? targetFiles.Distinct() : targetFiles;
return(content.ToString());
}
public CacheDecorator(ILessEngine underlying, ICache cache, ILogger logger)
{
Underlying = underlying;
Cache = cache;
Logger = logger;
}
public ParameterDecorator(ILessEngine underlying, IParameterSource parameterSource)
{
this.Underlying = underlying;
this.parameterSource = parameterSource;
}
private static IEnumerable<string> CompileImpl(ILessEngine engine, string inputFilePath, string outputFilePath)
{
engine = new FixImportPathDecorator(engine);
try
{
Console.WriteLine("{0} -> {1}", inputFilePath, outputFilePath);
var directoryPath = Path.GetDirectoryName(inputFilePath);
var fileReader = new dotless.Core.Input.FileReader();
var source = fileReader.GetFileContents(inputFilePath);
engine.CurrentDirectory = directoryPath;
var watch = new Stopwatch();
watch.Start();
var css = engine.TransformToCss(source, inputFilePath);
watch.Stop();
File.WriteAllText(outputFilePath, css);
if (!engine.LastTransformationSuccessful)
{
returnCode = -5;
Console.WriteLine();
Console.WriteLine("[Done - Failed]");
}
else
{
Console.WriteLine("[Done in {0}]", watch.Elapsed);
}
var files = new List<string>();
files.Add(inputFilePath);
foreach (var file in engine.GetImports())
files.Add(Path.Combine(directoryPath, Path.GetExtension(file)));
engine.ResetImports();
return files;
}
catch (IOException ex)
{
Console.WriteLine("[FAILED]");
Console.WriteLine("Compilation failed: {0}", ex.Message);
Console.WriteLine(ex.StackTrace);
returnCode = -2;
return null;
}
catch (Exception ex)
{
Console.WriteLine("[FAILED]");
Console.WriteLine("Compilation failed: {0}", ex.Message);
Console.WriteLine(ex.StackTrace);
returnCode = -3;
return null;
}
}
public CacheDecorator(ILessEngine underlying, ICache cache, ILogger logger)
{
Underlying = underlying;
Cache = cache;
Logger = logger;
}
public FixImportPathDecorator(ILessEngine underlying)
{
this.underlying = underlying;
}
public static void Main(string[] args)
{
Directory.SetCurrentDirectory("Input");
var files = Directory.GetFiles(".", "*.less");
var contents = files
.ToDictionary(f => f, f => File.ReadAllText(f));
const int rounds = 150;
Func <string, ILessEngine, int> runTest =
(file, engine) => Enumerable
.Range(0, rounds)
.Select(i =>
{
var starttime = DateTime.Now;
engine.TransformToCss(contents[file], file);
var duration = (DateTime.Now - starttime);
return(duration.Milliseconds);
})
.Sum();
Console.WriteLine("Press Enter to begin benchmark");
Console.ReadLine();
Console.WriteLine("Running each test {0} times\n", rounds);
var engines = new ILessEngine[]
{
new LessEngine()
};
Console.Write(" File | Size |");
foreach (var engine in engines)
{
Console.Write(engine.GetType().Name.PadRight(24).PadLeft(29));
Console.Write('|');
}
Console.WriteLine();
Console.WriteLine(new string('-', 35 + 30 * engines.Length));
foreach (var file in files)
{
var size = rounds * contents[file].Length / 1024d;
Console.Write("{0} | {1,8:#,##0.00} Kb | ", file.PadRight(18), size);
var times = new List <double>();
foreach (var engine in engines)
{
try
{
var time = runTest(file, engine) / 1000d;
times.Add(time);
Console.Write("{0,8:#.00} s {1,10:#,##0.00} Kb/s | ", time, size / time);
}
catch
{
Console.Write("Failied | ");
}
}
if (times.Count == 2)
{
Console.Write("{0,4:0.#}x", times[0] / times[1]);
}
Console.WriteLine();
}
// Console.Read();
}
public static string Parse(ILessEngine engine, string less)
{
return(Parse(engine, less, DotlessConfiguration.GetDefault()));
}
public void Process(BundleContext context, BundleResponse bundle)
{
context.HttpContext.Response.Cache.SetLastModifiedFromFileDependencies();
var content = new StringBuilder();
var bundleFiles = new List <BundleFile>();
foreach (var bundleFile in bundle.Files)
{
var lessParser = new Parser();
ILessEngine lessEngine = this.CreateLessEngine(lessParser);
bool foundMinimizedVersion = false;
bundleFiles.Add(bundleFile);
if (BundleTable.EnableOptimizations)
{
var ext = Path.GetExtension(bundleFile.VirtualFile.VirtualPath);
if (ext != null && ext.Equals(".less", StringComparison.InvariantCultureIgnoreCase))
{
var filepath = bundleFile.VirtualFile.VirtualPath;
var minimizedFileName = string.Format(
"{0}.min.css",
filepath.Substring(0, filepath.LastIndexOf(ext, StringComparison.Ordinal)));
var virtualPathProvider = HostingEnvironment.VirtualPathProvider;
if (virtualPathProvider.FileExists(minimizedFileName))
{
var minimizedFile = virtualPathProvider.GetFile(minimizedFileName);
foundMinimizedVersion = true;
using (var reader = new StreamReader(minimizedFile.Open()))
{
content.Append(reader.ReadToEnd());
content.AppendLine();
bundleFiles.Add(new BundleFile(minimizedFile.VirtualPath, minimizedFile));
}
}
}
}
if (!foundMinimizedVersion)
{
this.SetCurrentFilePath(lessParser, bundleFile.VirtualFile.VirtualPath);
using (var reader = new StreamReader(VirtualPathProvider.OpenFile(bundleFile.VirtualFile.VirtualPath)))
{
var fileContent = reader.ReadToEnd();
content.Append(lessEngine.TransformToCss(fileContent, bundleFile.VirtualFile.VirtualPath));
content.AppendLine();
bundleFiles.AddRange(this.GetFileDependencies(lessParser).Select(f => new BundleFile(f.VirtualPath, f)));
}
}
}
if (BundleTable.EnableOptimizations)
{
// include imports in bundle files to register cache dependencies
bundle.Files = bundleFiles.Distinct().ToList();
}
bundle.ContentType = "text/css";
bundle.Content = content.ToString();
}
public LessCompiler(ILessEngine engine)
{
_engine = engine;
}
private static IEnumerable<string> CompileImpl(ILessEngine engine, string inputFilePath, string outputFilePath, StringBuilder sb, bool silent)
{
try
{
if (!silent)
{
sb.AppendFormat("{0} -> {1}\n", inputFilePath, outputFilePath);
}
var directoryPath = Path.GetDirectoryName(inputFilePath);
var source = new dotless.Core.Input.FileReader(directoryPath).GetFileContents(inputFilePath);
var css = engine.TransformToCss(source, inputFilePath);
File.WriteAllText(outputFilePath, css);
if (!silent)
{
sb.AppendLine("[Done]");
}
var files = new List<string>();
files.Add(inputFilePath);
foreach (var file in engine.GetImports())
{
files.Add(Path.Combine(directoryPath, Path.ChangeExtension(file, "less")));
}
engine.ResetImports();
return files;
}
catch (IOException)
{
throw;
}
catch (Exception ex)
{
if (silent)
{
// Need to know the file now
sb.AppendFormat("{0} -> {1}\n", inputFilePath, outputFilePath);
}
sb.AppendLine("[FAILED]");
sb.AppendFormat("Compilation failed: {0}\n", ex.Message);
sb.AppendLine(ex.StackTrace);
return null;
}
}
public CacheDecorator(ILessEngine underlying, ICache cache)
: this(underlying, cache, NullLogger.Instance)
{
}
public static void Main(string[] args)
{
Directory.SetCurrentDirectory("Input");
var files = Directory.GetFiles(".", "*.less");
var contents = files
.ToDictionary(f => f, f => File.ReadAllText(f));
const int rounds = 150;
Func<string, ILessEngine, int> runTest =
(file, engine) => Enumerable
.Range(0, rounds)
.Select(i =>
{
var starttime = DateTime.Now;
engine.TransformToCss(contents[file], file);
var duration = (DateTime.Now - starttime);
return duration.Milliseconds;
})
.Sum();
Console.WriteLine("Press Enter to begin benchmark");
Console.ReadLine();
Console.WriteLine("Running each test {0} times\n", rounds);
var engines = new ILessEngine[]
{
new LessEngine()
};
Console.Write(" File | Size |");
foreach (var engine in engines)
{
Console.Write(engine.GetType().Name.PadRight(24).PadLeft(29));
Console.Write('|');
}
Console.WriteLine();
Console.WriteLine(new string('-', 35 + 30*engines.Length));
foreach (var file in files)
{
var size = rounds*contents[file].Length/1024d;
Console.Write("{0} | {1,8:#,##0.00} Kb | ", file.PadRight(18), size);
var times = new List<double>();
foreach (var engine in engines)
{
try
{
var time = runTest(file, engine)/1000d;
times.Add(time);
Console.Write("{0,8:#.00} s {1,10:#,##0.00} Kb/s | ", time, size/time);
}
catch
{
Console.Write("Failied | ");
}
}
if (times.Count == 2)
Console.Write("{0,4:0.#}x", times[0] / times[1]);
Console.WriteLine();
}
// Console.Read();
}
public ParameterDecorator(ILessEngine underlying, IParameterSource parameterSource)
{
this.Underlying = underlying;
this.parameterSource = parameterSource;
}
private static IEnumerable<string> CompileImpl(ILessEngine engine, string inputFilePath, string outputFilePath)
{
engine = new FixImportPathDecorator(engine);
var currentDir = Directory.GetCurrentDirectory();
try
{
Console.WriteLine("{0} -> {1}", inputFilePath, outputFilePath);
var directoryPath = Path.GetDirectoryName(inputFilePath);
var fileReader = new dotless.Core.Input.FileReader();
var source = fileReader.GetFileContents(inputFilePath);
Directory.SetCurrentDirectory(directoryPath);
var css = engine.TransformToCss(source, inputFilePath);
File.WriteAllText(outputFilePath, css);
if (!engine.LastTransformationSuccessful)
{
returnCode = -5;
Console.WriteLine();
Console.WriteLine("[Done - Failed]");
}
else
{
Console.WriteLine("[Done]");
}
var files = new List<string>();
files.Add(inputFilePath);
foreach (var file in engine.GetImports())
files.Add(Path.Combine(directoryPath, Path.ChangeExtension(file, "less")));
engine.ResetImports();
return files;
}
<<<<<<< HEAD
//catch (IOException)
//{
// throw;
//}
//catch (Exception ex)
//{
// Console.WriteLine("[FAILED]");
// Console.WriteLine("Compilation failed: {0}", ex.Message);
// Console.WriteLine(ex.StackTrace);
// return null;
//}
=======
catch (IOException)
{
returnCode = -2;
throw;
}
catch (Exception ex)
{
Console.WriteLine("[FAILED]");
Console.WriteLine("Compilation failed: {0}", ex.Message);
Console.WriteLine(ex.StackTrace);
returnCode = -3;
return null;
}
>>>>>>> 57986d4e1b45102058e055468254b85e34a41e98
finally
{
Directory.SetCurrentDirectory(currentDir);
}
}
private static CompilationDelegate CreationImpl(ILessEngine engine, string inputFilePath, string outputDirectoryPath)
{
var pathbuilder = new System.Text.StringBuilder(outputDirectoryPath + Path.DirectorySeparatorChar);
pathbuilder.Append(Path.ChangeExtension(Path.GetFileName(inputFilePath), "css"));
var outputFilePath = Path.GetFullPath(pathbuilder.ToString());
return () => CompileImpl(engine, inputFilePath, outputFilePath);
}
public CacheDecorator(ILessEngine underlying, ICache cache) : this(underlying, cache, NullLogger.Instance)
{
}
public AspCacheDecorator(ILessEngine underlying, ICache cache)
{
this.underlying = underlying;
this.cache = cache;
}
public MinifierDecorator(ILessEngine engine)
{
this.engine = engine;
}
