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 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(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);
});
}
public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
{
DotlessConfiguration config = DotlessConfiguration.GetDefault();
config.RootPath = context.InputFolder;
config.Logger = typeof (LessLogger);
EngineFactory engineFactory = new EngineFactory(config);
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);
return inputs.Select(x =>
{
string path = x.Get<string>("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();
}
using (context.Trace.WithIndent().Verbose("Processing Less for {0}", path ?? "inline content"))
{
string content = engine.TransformToCss(x.Content, fileName);
return x.Clone(content);
}
});
}
public string ProcessFile(string content, AssetType assetType, string physicalFilePath, string contentPath)
{
if (assetType == AssetType.CSS && physicalFilePath.ToUpperInvariant().EndsWith(".LESS"))
{
var factory = new EngineFactory();
var engine = factory.GetEngine(DotlessConfiguration.Default);
return engine.TransformToCss(new LessSourceObject() { Content = content });
}
return content;
}
public string ProcessCss(FileInfo file)
{
var content = fileSystem.File.ReadAllText(file.FullName);
//todo resolve imports
//_fileSystem.Directory.SetCurrentDirectory("");
var engineFactory = new EngineFactory();
engineFactory.Configuration.MinifyOutput = true;
var engine = engineFactory.GetEngine();
return engine.TransformToCss(content, file.FullName);
}
public void Minify()
{
var bundled = fileSystem.BundleFiles(files);
//todo resolve imports
//_fileSystem.Directory.SetCurrentDirectory("");
//minify
var engineFactory = new EngineFactory();
engineFactory.Configuration.MinifyOutput = true;
var engine = engineFactory.GetEngine();
var minified = engine.TransformToCss(bundled, files.First().FullName);
//build file
fileSystem.File.WriteAllText(outputPath, minified);
}
public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
{
DotlessConfiguration config = DotlessConfiguration.GetDefault();
config.RootPath = context.InputFolder;
config.Logger = typeof (LessLogger);
EngineFactory engineFactory = new EngineFactory(config);
return inputs.Select(x =>
{
ILessEngine engine = engineFactory.GetEngine();
string path = x.Get<string>("SourceFilePath", null);
string fileName = null;
if (path != null)
{
engine.CurrentDirectory = Path.GetDirectoryName(path);
fileName = Path.GetFileName(path);
}
string content = engine.TransformToCss(x.Content, fileName);
return x.Clone(content);
});
}
public override string Process(string filePath, string content)
{
var engineFactory = new EngineFactory();
var engine = engineFactory.GetEngine();
return engine.TransformToCss(content, filePath);
}
private string ProcessLess(string file)
{
var currentDirectory = Environment.CurrentDirectory;
try
{
Environment.CurrentDirectory = Path.GetDirectoryName(file) ?? currentDirectory;
var content = ReadFile(file);
var engineFactory = new EngineFactory();
var engine = engineFactory.GetEngine();
return engine.TransformToCss(content, file);
}
finally
{
Environment.CurrentDirectory = currentDirectory;
}
}
/// <summary>
/// The main method of the task.
/// </summary>
/// <param name="args">The arguments.</param>
/// <returns>The return code.</returns>
private int Main(string[] args)
{
var arguments = new List<string>();
arguments.AddRange(args);
var configuration = GetConfigurationFromArguments(arguments);
if (configuration.Help)
return -1;
if (arguments.Count == 0)
{
WriteHelp();
return -1;
}
string inputDirectoryPath, inputFilePattern;
if (Directory.Exists(arguments[0]))
{
inputDirectoryPath = arguments[0];
inputFilePattern = "*.less";
}
else
{
inputDirectoryPath = Path.GetDirectoryName(arguments[0]);
if (string.IsNullOrEmpty(inputDirectoryPath)) inputDirectoryPath = "." + Path.DirectorySeparatorChar;
inputFilePattern = Path.GetFileName(arguments[0]);
if (!Path.HasExtension(inputFilePattern)) inputFilePattern = Path.ChangeExtension(inputFilePattern, "less");
}
var outputDirectoryPath = string.Empty;
var outputFilename = string.Empty;
if (arguments.Count > 1)
{
if (Directory.Exists(arguments[1]))
{
outputDirectoryPath = arguments[1];
}
else
{
outputDirectoryPath = Path.GetDirectoryName(arguments[1]);
outputFilename = Path.GetFileName(arguments[1]);
if (!Path.HasExtension(outputFilename))
outputFilename = Path.ChangeExtension(outputFilename, "css");
}
}
if (string.IsNullOrEmpty(outputDirectoryPath))
{
outputDirectoryPath = inputDirectoryPath;
}
else
{
Directory.CreateDirectory(outputDirectoryPath);
}
if (HasWildcards(inputFilePattern))
{
if (!string.IsNullOrEmpty(outputFilename))
{
Log.LogError("Output filename patterns/filenames are not supported when using input wildcards. You may only specify an output directory (end the output in a directory seperator)");
return -1;
}
outputFilename = string.Empty;
}
var filenames = Directory.GetFiles(inputDirectoryPath, inputFilePattern);
if (filenames.Count() == 0)
{
Log.LogError("No files found matching pattern '{0}'", inputFilePattern);
return -1;
}
var engineFactory = new EngineFactory(configuration);
var containerFactory = new dotlessCompilerContainerFactory(this);
var engine = engineFactory.GetEngine(containerFactory);
foreach (var filename in filenames)
{
var inputFile = new FileInfo(filename);
var outputFile =
string.IsNullOrEmpty(outputFilename) ?
Path.Combine(outputDirectoryPath, Path.ChangeExtension(inputFile.Name, "css")) :
Path.Combine(outputDirectoryPath, outputFilename);
var outputFilePath = Path.GetFullPath(outputFile);
var returnCode = CompileImpl(engine, inputFile.FullName, outputFilePath);
if (returnCode != 0)
{
// IF not zero
// THEN return the failure code
return returnCode;
}
}
return ReturnCode;
}
private string ProcessLess(string file)
{
lock (typeof(CssBundle))
{
try
{
currentDirectoryWrapper.SetCurrentDirectory(Path.GetDirectoryName(file));
var content = ReadFile(file);
var engineFactory = new EngineFactory();
var engine = engineFactory.GetEngine();
return engine.TransformToCss(content, file);
}
finally
{
currentDirectoryWrapper.Revert();
}
}
}