/// <summary>The initialize.</summary>
/// <param name="configuration">The configuration.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="cacheManager">The cache manager.</param>
/// <param name="preprocessingManager">The preprocessing manager.</param>
/// <param name="runStartTime">The run start time.</param>
/// <param name="timeMeasure">The time measure.</param>
private void Initialize(
WebGreaseConfiguration configuration,
LogManager logManager,
ICacheManager cacheManager,
PreprocessingManager preprocessingManager,
DateTimeOffset runStartTime,
ITimeMeasure timeMeasure)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (configuration.Global.TreatWarningsAsErrors != null)
{
logManager.TreatWarningsAsErrors = configuration.Global.TreatWarningsAsErrors == true;
}
// Note: Configuration needs to be set before the other ones.
this.Configuration = configuration;
this.Configuration.Validate();
this.Measure = timeMeasure;
this.Log = logManager;
this.Cache = cacheManager;
this.Preprocessing = preprocessingManager;
this.SessionStartTime = runStartTime;
this.Cache.SetContext(this);
this.Preprocessing.SetContext(this);
}
/// <summary>Initializes a new instance of the <see cref="WebGreaseContext"/> class.</summary>
/// <param name="parentContext">The parent context.</param>
/// <param name="configFile">The config file.</param>
public WebGreaseContext(IWebGreaseContext parentContext, FileInfo configFile)
{
var configuration = new WebGreaseConfiguration(parentContext.Configuration, configFile);
configuration.Validate();
if (configuration.Global.TreatWarningsAsErrors != null && parentContext.Log != null)
{
parentContext.Log.TreatWarningsAsErrors = configuration.Global.TreatWarningsAsErrors == true;
}
var parentWebGreaseContext = parentContext as WebGreaseContext;
if (parentWebGreaseContext != null)
{
this.threadedMeasureResults = parentWebGreaseContext.threadedMeasureResults;
}
this.Initialize(
configuration,
parentContext.Log,
parentContext.Cache,
parentContext.Preprocessing,
parentContext.SessionStartTime,
parentContext.Measure);
}
public void ResourcePivotConfigurationTest()
{
var configuration = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" +
"<WebGrease><Settings> <ResourcePivot key=\"locales\" applyMode=\"CssApplyAfterParse\">ja-jp;th-th;zh-sg;generic-generic</ResourcePivot>" +
"<ResourcePivot key=\"themes\" applyMode=\"CssApplyAfterParse\">red;blue;orange;green;purple</ResourcePivot>" +
"<Dpi>1;1.4;1.5;1.8;2;2.25;2.4</Dpi></Settings></WebGrease>";
var tmpFile = Path.GetTempFileName();
File.WriteAllText(tmpFile, configuration);
var configurationFile = new FileInfo(tmpFile);
var wgc = new WebGreaseConfiguration(configurationFile, configurationFile.DirectoryName, configurationFile.DirectoryName, configurationFile.DirectoryName, configurationFile.DirectoryName);
Assert.AreEqual(1, wgc.DefaultDpi.Count);
Assert.AreEqual(string.Empty, wgc.DefaultDpi.Keys.ElementAt(0));
var dpis = wgc.DefaultDpi.Values.ElementAt(0);
Assert.AreEqual(7f, dpis.Count);
Assert.AreEqual(1.4f, dpis.ElementAtOrDefault(1));
Assert.AreEqual(2.25f, dpis.ElementAtOrDefault(5));
Assert.AreEqual(2.4f, dpis.ElementAtOrDefault(6));
Assert.AreEqual(2, wgc.DefaultJsResourcePivots.Count());
Assert.AreEqual("locales", wgc.DefaultJsResourcePivots.ElementAtOrDefault(0).Key);
Assert.AreEqual(4, wgc.DefaultJsResourcePivots["locales"].Keys.Count);
Assert.AreEqual("themes", wgc.DefaultJsResourcePivots.ElementAtOrDefault(1).Key);
Assert.AreEqual(5, wgc.DefaultJsResourcePivots["themes"].Keys.Count);
}
public void ResourcePivotResourcesTmxSdkTest1()
{
var sourceDirectory = Path.Combine(TestDeploymentPaths.TestDirectory, @"WebGrease.Tests\ResourcesResolutionActivityTest\ResourcePivotTest1");
LogExtendedError logExtendedError = (subcategory, code, keyword, file, number, columnNumber, lineNumber, endColumnNumber, message) => Assert.Fail(message);
var errors = new List <string>();
Action <string> logErrorMessage = errors.Add;
LogError logError = (exception, message, name) => errors.Add(message);
var start = DateTimeOffset.UtcNow;
var webGreaseConfiguration = new WebGreaseConfiguration(
new FileInfo(Path.Combine(sourceDirectory, "LandingPage.xml")),
"Release",
sourceDirectory,
Path.Combine(sourceDirectory, "output1"),
Path.Combine(sourceDirectory, "logs1"),
Path.Combine(sourceDirectory, "temp1"),
sourceDirectory);
var webGreaseContext = new WebGreaseContext(webGreaseConfiguration, null, null, logExtendedError, logErrorMessage, logError);
new EverythingActivity(webGreaseContext).Execute();
var time1 = DateTimeOffset.UtcNow - start;
start = DateTimeOffset.UtcNow;
var webGreaseConfiguration2 = new WebGreaseConfiguration(
new FileInfo(Path.Combine(sourceDirectory, "LandingPage2.xml")),
"Release",
sourceDirectory,
Path.Combine(sourceDirectory, "output2"),
Path.Combine(sourceDirectory, "logs2"),
Path.Combine(sourceDirectory, "temp2"),
sourceDirectory);
var webGreaseContext2 = new WebGreaseContext(webGreaseConfiguration2, null, null, logExtendedError, logErrorMessage, logError);
new EverythingActivity(webGreaseContext2).Execute();
if (errors.Count > 0)
{
foreach (var error in errors)
{
Trace.WriteLine("Error: " + error);
}
Assert.Fail("Errors occurred, see test output for details.");
}
var time2 = DateTimeOffset.UtcNow - start;
Trace.WriteLine(string.Format("Parsed: {0}ms, Cloned: {1}ms", time1.TotalMilliseconds, time2.TotalMilliseconds));
Func <string, string> logFileChange = logFileContent => logFileContent.Replace("/output1/", "/output2/");
CacheTests.DirectoryMatch(Path.Combine(sourceDirectory, "output1"), Path.Combine(sourceDirectory, "output2"), logFileChange);
CacheTests.DirectoryMatch(Path.Combine(sourceDirectory, "output2"), Path.Combine(sourceDirectory, "output1"), logFileChange);
}
/// <summary>
/// Constructs a instance of WebGrease Semantic CSS minifier
/// </summary>
/// <param name="wgConfig">Configuration settings of WebGrease Minifier</param>
public WgCssMinifier(WgSettings wgConfig)
{
CssMinifierSettings cssMinifierConfig = wgConfig.CssMinifier;
ShouldMinify = cssMinifierConfig.ShouldMinify;
EjectCharset = cssMinifierConfig.EjectCharset;
_wgConfiguration = CreateWebGreaseConfiguration();
}
/// <summary>Initializes a new instance of the <see cref="WebGreaseContext"/> class. The web grease context.</summary>
/// <param name="configuration">The configuration</param>
/// <param name="logManager">The log Manager.</param>
/// <param name="parentCacheSection">The parent Cache Section.</param>
/// <param name="preprocessingManager">The preprocessing Manager.</param>
public WebGreaseContext(WebGreaseConfiguration configuration, LogManager logManager, ICacheSection parentCacheSection = null, PreprocessingManager preprocessingManager = null)
{
var runStartTime = DateTimeOffset.Now;
configuration.Validate();
var timeMeasure = configuration.Measure ? new TimeMeasure() as ITimeMeasure : new NullTimeMeasure();
var cacheManager = configuration.CacheEnabled ? new CacheManager(configuration, logManager, parentCacheSection) as ICacheManager : new NullCacheManager();
this.Initialize(
configuration,
logManager,
cacheManager,
preprocessingManager != null ? new PreprocessingManager(preprocessingManager) : new PreprocessingManager(configuration, logManager, timeMeasure),
runStartTime,
timeMeasure);
}
/// <summary>The get file sets.</summary>
/// <param name="configuration">The configuration.</param>
/// <param name="fileType">The file type.</param>
/// <returns>The filesets fot the file type.</returns>
private static IEnumerable <IFileSet> GetFileSets(WebGreaseConfiguration configuration, FileTypes fileType)
{
var result = new List <IFileSet>();
if (fileType.HasFlag(FileTypes.JS))
{
result.AddRange(configuration.JSFileSets);
}
if (fileType.HasFlag(FileTypes.CSS))
{
result.AddRange(configuration.CssFileSets);
}
return(result);
}
public void MainActivityDebugIntegrationTest()
{
var testSourceDirectory = Path.Combine(TestDeploymentPaths.TestDirectory, @"WebGrease.Tests\MainActivityTest");
var configurationFile = Path.Combine(testSourceDirectory, @"Input\Integration\Debug\Configuration\sample1.webgrease.config");
var sourceDirectory = Path.Combine(testSourceDirectory, @"Input\Integration\Debug\Content");
var destinationDirectory = Path.Combine(testSourceDirectory, @"Output\Integration\Debug\sc");
var logsDirectory = Path.Combine(testSourceDirectory, @"Output\Integration\Debug\logs");
var webGreaseConfigurationRoot = new WebGreaseConfiguration(new FileInfo(configurationFile), "Debug", sourceDirectory, destinationDirectory, logsDirectory);
var context = new WebGreaseContext(webGreaseConfigurationRoot, logInformation: null, logExtendedWarning: null, logError: LogError, logExtendedError: LogExtendedError);
var mainActivity = new EverythingActivity(context);
var success = mainActivity.Execute();
Assert.IsTrue(success);
VerifyStatics(destinationDirectory, logsDirectory);
}
public void WebGreaseConfigurationDefaults()
{
// parse the configuration file
var configurationFile = Path.Combine(TestDeploymentPaths.TestDirectory, @"WebGrease.Tests\WebGreaseConfigurationRootTest\Input\Debug\Configuration\withDefaults.webgrease.config");
var configDirectory = Path.GetDirectoryName(configurationFile);
var webGreaseConfigurationRoot = new WebGreaseConfiguration(new FileInfo(configurationFile), null, configDirectory, configDirectory, configDirectory);
Assert.IsNotNull(webGreaseConfigurationRoot);
// there should be two CSS file sets and two JS file sets
Assert.IsTrue(webGreaseConfigurationRoot.CssFileSets.Count == 2);
Assert.IsTrue(webGreaseConfigurationRoot.JSFileSets.Count == 2);
ValidateCssFileSet(webGreaseConfigurationRoot.CssFileSets[0],
new[] { "en-us", "en-ca", "fr-ca", "en-gb" },
new[] { "Red", "Orange", "Yellow", "Green", "Blue", "Violet" },
new CssMinificationConfig {
Name = "Retail", ShouldMinify = true, ShouldValidateLowerCase = true, ForbiddenSelectors = new[] { "body" }
},
new CssMinificationConfig {
Name = "Debug", ShouldMinify = false, ShouldValidateLowerCase = false, ForbiddenSelectors = new string[] { }
});
ValidateCssFileSet(webGreaseConfigurationRoot.CssFileSets[1],
new[] { "zh-sg", "zh-tw", "zh-hk" },
new[] { "Pink", "Green" },
new CssMinificationConfig {
Name = "Retail", ShouldMinify = false, ShouldValidateLowerCase = false, ForbiddenSelectors = new string[] { }
},
null);
ValidateJsFileSet(webGreaseConfigurationRoot.JSFileSets[0],
new[] { "en-us", "en-ca", "fr-ca", "en-gb" },
new JsMinificationConfig {
Name = "Retail", ShouldMinify = true, GlobalsToIgnore = "jQuery;$;define", MinificationArugments = "-evals:safe -fnames:lock"
},
new JsMinificationConfig {
Name = "Debug", ShouldMinify = false, GlobalsToIgnore = "FooBar", MinificationArugments = string.Empty
});
ValidateJsFileSet(webGreaseConfigurationRoot.JSFileSets[1],
new[] { "es-es", "es-mx", "es-ar" },
new JsMinificationConfig {
Name = "Retail", ShouldMinify = false, GlobalsToIgnore = string.Empty, MinificationArugments = string.Empty
},
null);
}
/// <summary>Initializes a new instance of the <see cref="PreprocessingManager"/> class.
/// Initializes a new instance of the <see cref="PreprocessingManager"/>.
/// Can only be called from within the class by the Singleton construction.</summary>
/// <param name="webGreaseConfiguration">The web Grease Configuration.</param>
/// <param name="logManager">The log Manager.</param>
/// <param name="timeMeasure">The time Measure.</param>
internal PreprocessingManager(WebGreaseConfiguration webGreaseConfiguration, LogManager logManager, ITimeMeasure timeMeasure)
{
if (webGreaseConfiguration == null)
{
throw new ArgumentNullException("webGreaseConfiguration");
}
if (logManager == null)
{
throw new ArgumentNullException("logManager");
}
if (timeMeasure == null)
{
throw new ArgumentNullException("timeMeasure");
}
this.Initialize(webGreaseConfiguration.PreprocessingPluginPath, logManager, timeMeasure);
}
public void ResourcePivotConfigurationLegacyTest()
{
var configuration = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" +
"<WebGrease><Settings> <Locales>ja-jp;th-th;zh-sg;generic-generic</Locales>" +
"<Themes>red;blue;orange;green;purple</Themes>" +
"</Settings></WebGrease>";
var tmpFile = Path.GetTempFileName();
File.WriteAllText(tmpFile, configuration);
var configurationFile = new FileInfo(tmpFile);
var wgc = new WebGreaseConfiguration(configurationFile, configurationFile.DirectoryName, configurationFile.DirectoryName, configurationFile.DirectoryName, configurationFile.DirectoryName);
Assert.AreEqual(1, wgc.DefaultJsResourcePivots.Count());
Assert.AreEqual(2, wgc.DefaultCssResourcePivots.Count());
Assert.AreEqual("locales", wgc.DefaultCssResourcePivots.ElementAtOrDefault(0).Key);
Assert.AreEqual(4, wgc.DefaultCssResourcePivots["locales"].Keys.Count);
Assert.AreEqual("themes", wgc.DefaultCssResourcePivots.ElementAtOrDefault(1).Key);
Assert.AreEqual(5, wgc.DefaultCssResourcePivots["themes"].Keys.Count);
}
/// <summary>Initializes a new instance of the <see cref="CacheManager"/> class.</summary>
/// <param name="configuration">The configuration.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="parentCacheSection">The parent Cache Section.</param>
public CacheManager(WebGreaseConfiguration configuration, LogManager logManager, ICacheSection parentCacheSection)
{
this.currentCacheSection = parentCacheSection;
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (logManager == null)
{
throw new ArgumentNullException("logManager");
}
var cacheRoot = configuration.CacheRootPath.AsNullIfWhiteSpace() ?? "_webgrease.cache";
if (!Path.IsPathRooted(cacheRoot))
{
cacheRoot = Path.Combine(configuration.SourceDirectory, cacheRoot);
}
this.cacheRootPath = GetCacheUniquePath(cacheRoot, configuration.CacheUniqueKey);
if (!Directory.Exists(this.cacheRootPath))
{
Directory.CreateDirectory(this.cacheRootPath);
}
Safe.Lock(
First,
() =>
{
// Only log this once when multi threading.
if (First.Contains(this.cacheRootPath))
{
First.Add(this.cacheRootPath);
logManager.Information("Cache enabled using cache path: {0}".InvariantFormat(this.cacheRootPath));
}
});
}
/// <summary>
/// Overrides the given configuration object withe
/// </summary>
/// <param name="wgConfig">config file to override</param>
/// <param name="logPath">path of the log files</param>
/// <param name="tokenPath">token file path</param>
/// <param name="imagePath">image file path</param>
/// <returns>an overriden config object</returns>
private static WebGreaseConfiguration OverrideConfig(WebGreaseConfiguration wgConfig, string logPath, string tokenPath, string imagePath)
{
// images path
if (!imagePath.IsNullOrWhitespace())
{
// clear out existing config values as cmd line values override.
wgConfig.ImageDirectories.Clear();
wgConfig.ImageDirectories.Add(imagePath);
wgConfig.ImageExtensions = Strings.DefaultImageExtensions;
}
// token path
if (!tokenPath.IsNullOrWhitespace())
{
// TODO: should CLI allow specifying override dir as well?
wgConfig.TokensDirectory = tokenPath;
}
wgConfig.LogsDirectory = logPath;
return(wgConfig);
}
public void WebGreaseConfigurationTest()
{
var configurationFile = Path.Combine(TestDeploymentPaths.TestDirectory, @"WebGrease.Tests\WebGreaseConfigurationRootTest\Input\Debug\Configuration\sample1.webgrease.config");
var configDirectory = Path.GetDirectoryName(configurationFile);
var webGreaseConfigurationRoot = new WebGreaseConfiguration(new FileInfo(configurationFile), null, configDirectory, configDirectory, configDirectory);
Assert.IsNotNull(webGreaseConfigurationRoot);
var imageDirectories = webGreaseConfigurationRoot.ImageDirectories;
Assert.IsNotNull(imageDirectories);
Assert.IsTrue(imageDirectories.Count == 2);
Assert.IsTrue(imageDirectories[0].EndsWith(@"f1\i"));
Assert.IsTrue(imageDirectories[1].EndsWith(@"f2\i"));
var imageExtensions = webGreaseConfigurationRoot.ImageExtensions;
Assert.IsNotNull(imageExtensions);
Assert.IsTrue(imageExtensions.Count == 5);
Assert.IsTrue(imageExtensions[0] == "png");
Assert.IsTrue(imageExtensions[1] == "jpg");
var tokensDir = webGreaseConfigurationRoot.TokensDirectory;
Assert.AreEqual(tokensDir, "App", "TokensDirectory should be 'App' but was '{0}'", tokensDir);
var tokenOverrideDir = webGreaseConfigurationRoot.OverrideTokensDirectory;
Assert.AreEqual(tokenOverrideDir, "Site1", "OverrideTokensDirectory should be 'Site1' but was '{0}'", tokenOverrideDir);
var cssFileSets = webGreaseConfigurationRoot.CssFileSets;
Assert.IsNotNull(cssFileSets);
Assert.AreEqual(2, cssFileSets.Count, "should be 2 CssFileSet objects");
var cssSet1 = cssFileSets[0];
var minificationConfigs = cssSet1.Minification;
Assert.IsNotNull(minificationConfigs);
Assert.IsTrue(minificationConfigs.Count == 2);
Assert.IsTrue(minificationConfigs.ContainsKey("DeBuG"));
Assert.IsTrue(minificationConfigs.ContainsKey("RELEASE"));
var minifyConfig = minificationConfigs["relEASE"];
Assert.IsNotNull(minifyConfig);
Assert.IsTrue(minifyConfig.Name == "Release");
Assert.IsTrue(minifyConfig.ShouldMinify);
Assert.IsTrue(minifyConfig.ShouldPreventOrderBasedConflict);
Assert.IsFalse(minifyConfig.ShouldMergeBasedOnCommonDeclarations);
Assert.IsTrue(minifyConfig.NonMergeSelectors.Contains("@font-face"));
Assert.IsTrue(minifyConfig.NonMergeSelectors.Contains(".specialSelector"));
var spriteConfiguration = cssSet1.ImageSpriting["RElease"];
Assert.IsTrue(spriteConfiguration.ShouldAutoSprite);
Assert.IsTrue(spriteConfiguration.ShouldAutoVersionBackgroundImages);
var locales = cssSet1.Locales;
Assert.IsNotNull(locales);
Assert.IsTrue(locales.Count() == 2);
Assert.IsTrue(locales[0] == "en-us");
Assert.IsTrue(locales[1] == "fr-ca");
var themes = cssSet1.Themes;
Assert.IsNotNull(themes);
Assert.IsTrue(themes.Count() == 2);
Assert.IsTrue(themes[0] == "red");
Assert.IsTrue(themes[1] == "blue");
var inputs = cssSet1.InputSpecs;
Assert.IsNotNull(inputs);
Assert.AreEqual(3, inputs.Count);
var input = inputs[2];
Assert.AreEqual("*_mobile.css", input.SearchPattern, "search pattern should be '*_mobile.css'.");
Assert.AreEqual(SearchOption.TopDirectoryOnly, input.SearchOption, "search option should be 'TopDirectoryOnly'.");
Assert.IsTrue(input.Path.EndsWith(@"content\css"), "path should be 'content/css'.");
// now the js portion
var jsFileSets = webGreaseConfigurationRoot.JSFileSets;
Assert.IsNotNull(jsFileSets);
Assert.AreEqual(1, jsFileSets.Count, "should be 1 JsFileSet object");
var jsSet1 = jsFileSets[0];
var jsConfigurations = jsSet1.Minification;
Assert.IsNotNull(jsConfigurations);
Assert.AreEqual(2, jsConfigurations.Count);
Assert.IsTrue(jsConfigurations.ContainsKey("DEBUG"));
Assert.IsTrue(jsConfigurations.ContainsKey("RELEASE"));
var jsConfig = jsConfigurations["RELEASE"];
Assert.IsNotNull(jsConfig);
var jsGlobalsToIgnore = jsConfig.GlobalsToIgnore.Split(';');
Assert.IsNotNull(jsGlobalsToIgnore);
Assert.IsTrue(jsGlobalsToIgnore.Length == 2);
Assert.IsTrue(jsGlobalsToIgnore[0] == "jQuery");
Assert.IsTrue(jsGlobalsToIgnore[1] == "Msn");
}
/// <summary>
/// Constructs a instance of WebGrease Semantic CSS-minifier
/// </summary>
/// <param name="wgConfig">Configuration settings of WebGrease Minifier</param>
public WgCssMinifier(WgSettings wgConfig)
{
CssMinifierSettings cssMinifierConfig = wgConfig.CssMinifier;
ShouldMinify = cssMinifierConfig.ShouldMinify;
EjectCharset = cssMinifierConfig.EjectCharset;
_wgConfiguration = CreateWebGreaseConfiguration();
}
/// <summary>Creates the input spec objects based on input and output paths.</summary>
/// <param name="wgConfig">Config object to use.</param>
/// <param name="inputPath">Input path from the command parameters</param>
/// <param name="outputPath">output path from the command parameters</param>
private static void AddInputSpecs(WebGreaseConfiguration wgConfig, string inputPath, string outputPath)
{
if (inputPath.IsNullOrWhitespace() && outputPath.IsNullOrWhitespace())
{
// no paths need to be overriden.
return;
}
string outputPathExtension = Path.GetExtension(outputPath);
string inputPathExtension = Path.GetExtension(inputPath);
bool createCssInput = false;
bool createJsInput = false;
// Set the file filter to the extension of the output path (if it's a file)
if (!outputPathExtension.IsNullOrWhitespace())
{
// if the output path is a file we only process css OR js files into it.
if (outputPathExtension.EndsWith(Strings.Css, StringComparison.OrdinalIgnoreCase))
{
createCssInput = true;
}
else
{
createJsInput = true;
}
}
else if (!inputPathExtension.IsNullOrWhitespace())
{
// if the input path is not a folder, only set one of the file sets for processing
if (inputPathExtension.EndsWith(Strings.Css, StringComparison.OrdinalIgnoreCase))
{
createCssInput = true;
}
else
{
createJsInput = true;
}
}
else
{
// if both the intput and output path are not a file, assume they are a folder process both JS and CSS files found within.
createCssInput = true;
createJsInput = true;
}
var cssFileSet = new CssFileSet();
var jsFileSet = new JSFileSet();
// set or update input specs
if (createCssInput)
{
cssFileSet.InputSpecs.Add(GetInputSpec(inputPath, Strings.CssFilter));
}
if (createJsInput)
{
if (jsFileSet.InputSpecs.Any())
{
jsFileSet.InputSpecs.Clear();
}
jsFileSet.InputSpecs.Add(GetInputSpec(inputPath, Strings.JsFilter));
}
// set output spec
jsFileSet.Output = outputPath;
cssFileSet.Output = outputPath;
wgConfig.JSFileSets.Add(jsFileSet);
wgConfig.CssFileSets.Add(cssFileSet);
}
/// <summary>Initializes a new instance of the <see cref="WebGreaseContext"/> class. The web grease context.</summary>
/// <param name="configuration">The configuration</param>
/// <param name="logInformation">The log information.</param>
/// <param name="logWarning">The log Warning.</param>
/// <param name="logExtendedWarning">The log warning.</param>
/// <param name="logErrorMessage">The log Error Message.</param>
/// <param name="logError">The log error.</param>
/// <param name="logExtendedError">The log extended error.</param>
public WebGreaseContext(WebGreaseConfiguration configuration, Action <string, MessageImportance> logInformation = null, Action <string> logWarning = null, LogExtendedError logExtendedWarning = null, Action <string> logErrorMessage = null, LogError logError = null, LogExtendedError logExtendedError = null)
: this(configuration, new LogManager(logInformation, logWarning, logExtendedWarning, logErrorMessage, logError, logExtendedError, configuration.Global.TreatWarningsAsErrors))
{
}
/// <summary>Finalizes the measure values, stores thejm on disk if configured that way.</summary>
/// <param name="success">If the activity was successfull.</param>
/// <param name="activityResults">The activity results.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="start">The start time of the current run..</param>
/// <param name="activity">The current activity name.</param>
/// <param name="configuration">The configuration.</param>
private void FinalizeMeasure(bool success, IEnumerable <Tuple <string, bool, IEnumerable <TimeMeasureResult> > > activityResults, LogManager logManager, DateTimeOffset start, ActivityName?activity, WebGreaseConfiguration configuration)
{
if (this.Measure && success && activityResults.Any())
{
if (configuration != null)
{
var reportFileBase = Path.Combine(configuration.ReportPath, new DirectoryInfo(this.ConfigurationPath).Name);
logManager.Information("Writing overal report file to:".InvariantFormat(reportFileBase));
TimeMeasure.WriteResults(reportFileBase, activityResults, this.ConfigurationPath, start, activity.ToString());
}
this.MeasureResults = activityResults.SelectMany(ar => ar.Item3).ToArray();
}
}
public void ConfigSourceTest()
{
var configurationFile = Path.Combine(TestDeploymentPaths.TestDirectory, @"WebGrease.Tests\WebGreaseConfigurationRootTest\ConfigSource\configsource.webgrease.config");
var configDirectory = Path.GetDirectoryName(configurationFile);
var config = new WebGreaseConfiguration(new FileInfo(configurationFile), null, configDirectory, configDirectory, configDirectory);
// global1.config
Assert.IsTrue(config.ImageDirectories.All(id => id.EndsWith("global1imagedirectories")));
Assert.IsTrue(config.ImageExtensions.Contains("global1imageextensions"));
// global2.config
Assert.AreEqual(config.TokensDirectory, "global2tokendirectory");
// global3.config
Assert.AreEqual(config.OverrideTokensDirectory, "global3overridetokendirectory");
// css fileset 1 - settings\css1.config
var cssfileset1 = config.CssFileSets[0];
Assert.IsNotNull(cssfileset1);
Assert.AreEqual(2, cssfileset1.Themes.Count());
Assert.IsTrue(cssfileset1.Themes.Contains("red"));
Assert.IsTrue(cssfileset1.Themes.Contains("blue"));
Assert.AreEqual(2, cssfileset1.Locales.Count());
Assert.IsTrue(cssfileset1.Locales.Contains("en-us"));
Assert.IsTrue(cssfileset1.Locales.Contains("fr-ca"));
var debugMinification = cssfileset1.Minification.GetNamedConfig("deBUG");
var defaultMinification = cssfileset1.Minification.GetNamedConfig();
Assert.AreEqual(debugMinification, defaultMinification);
Assert.IsNotNull(debugMinification);
Assert.AreEqual("Debug", debugMinification.Name);
Assert.AreEqual(false, debugMinification.ShouldValidateLowerCase);
var releaseMinification = cssfileset1.Minification.GetNamedConfig("release");
Assert.AreNotEqual(debugMinification, releaseMinification);
Assert.AreEqual(true, releaseMinification.ShouldValidateLowerCase);
var defaultSpriting = cssfileset1.ImageSpriting.GetNamedConfig();
Assert.AreEqual(string.Empty, defaultSpriting.Name);
Assert.AreEqual(false, defaultSpriting.ShouldAutoSprite);
var releaseSpriting = cssfileset1.ImageSpriting.GetNamedConfig("Release");
Assert.AreEqual("Release", releaseSpriting.Name);
Assert.AreEqual(true, releaseSpriting.ShouldAutoSprite);
// css fileset 2 - settings\css2.config
var cssfileset2 = config.CssFileSets.FirstOrDefault(fs => fs.Output.Equals("cssfileset2.css"));
Assert.IsNotNull(cssfileset2);
Assert.AreEqual(2, cssfileset2.Themes.Count());
Assert.IsTrue(cssfileset2.Themes.Contains("themecss2a"));
Assert.IsTrue(cssfileset2.Themes.Contains("themecss2b"));
Assert.AreEqual(2, cssfileset2.Locales.Count());
Assert.IsTrue(cssfileset2.Locales.Contains("localecss2a"));
Assert.IsTrue(cssfileset2.Locales.Contains("localecss2b"));
var debugPreprocessing = cssfileset2.Preprocessing.GetNamedConfig("debug");
Assert.IsNotNull(debugPreprocessing);
Assert.IsNotNull(debugPreprocessing.Element);
Assert.AreEqual(debugPreprocessing.Element.Elements("Sass").Attributes("sourceMaps").Select(s => (bool?)s).FirstOrDefault(), true);
Assert.AreEqual("Debug", debugPreprocessing.Name);
Assert.AreEqual(1, debugPreprocessing.PreprocessingEngines.Count);
Assert.AreEqual("sass", debugPreprocessing.PreprocessingEngines[0]);
Assert.AreEqual(true, debugPreprocessing.Enabled);
var releasePreprocessing = cssfileset2.Preprocessing.GetNamedConfig("REleasE");
Assert.IsNotNull(releasePreprocessing);
Assert.IsNotNull(releasePreprocessing.Element);
Assert.IsNull(releasePreprocessing.Element.Elements("Sass").Attributes("sourceMaps").Select(s => (bool?)s).FirstOrDefault());
Assert.AreEqual("Release", releasePreprocessing.Name);
Assert.AreEqual(1, releasePreprocessing.PreprocessingEngines.Count);
Assert.AreEqual("sass", releasePreprocessing.PreprocessingEngines[0]);
Assert.AreEqual(true, releasePreprocessing.Enabled);
// js fileset 1 - settings\css1.config
var jsfileset1 = config.JSFileSets.FirstOrDefault(fs => fs.Output.Equals("jsfileset1.js"));
Assert.IsNotNull(jsfileset1);
Assert.AreEqual(2, jsfileset1.Locales.Count());
Assert.IsTrue(jsfileset1.Locales.Contains("jsinclude1"));
Assert.IsTrue(jsfileset1.Locales.Contains("jsinclude2"));
var debugJsMinification = jsfileset1.Minification.GetNamedConfig("DEBUG");
Assert.IsNotNull(debugJsMinification);
Assert.AreEqual("Debug", debugJsMinification.Name);
Assert.AreEqual("jQuery;Msn", debugJsMinification.GlobalsToIgnore);
var releaseJsMinification = jsfileset1.Minification.GetNamedConfig("release");
Assert.IsNotNull(releaseJsMinification);
Assert.AreEqual("Release", releaseJsMinification.Name);
Assert.AreEqual("jQuery2;Msn2", releaseJsMinification.GlobalsToIgnore);
}
internal static ActivityMode GenerateConfiguration(IEnumerable <string> args, out WebGreaseConfiguration wgConfig)
{
// reset activity flag since this is a new run
_isActivityAlreadySet = false;
Contract.Requires(args != null);
string configFileName = null;
string inputPath = Environment.CurrentDirectory;
string outputPath = Environment.CurrentDirectory;
string logPath = Environment.CurrentDirectory;
string tokenPath = null;
string imagePath = null;
string configType = null;
var activityToRun = ActivityMode.ShowHelp;
// process the arguments into variables
foreach (string arg in args)
{
// int value of char '-'
if (arg[0] == '-')
{
// split the arg into a key/value pair using a colon as the delimeter.
int split = arg.IndexOf(':');
string key = arg.Substring(1, (split > 0 ? split : arg.Length) - 1);
string value = split > -1 ? arg.Substring(split + 1) : string.Empty;
switch (key.ToUpperInvariant())
{
case "C":
// config file .. trumps all CLI parameters when used.
configFileName = value;
break;
case "M":
// minification of files
activityToRun = TrySetActivity(ActivityMode.Minify);
break;
case "V":
// validation of files
activityToRun = TrySetActivity(ActivityMode.Validate);
break;
case "S":
// Spriting of images
activityToRun = TrySetActivity(ActivityMode.SpriteImages);
break;
case "A":
// auto naming of files
activityToRun = TrySetActivity(ActivityMode.AutoName);
break;
case "B":
// Bundle (merge) files
activityToRun = TrySetActivity(ActivityMode.Bundle);
break;
case "IN":
// input file/folder
inputPath = value;
break;
case "OUT":
// output file/folder
outputPath = value;
break;
case "IMAGES":
// images folder
imagePath = value;
break;
case "LOG":
logPath = value;
break;
case "TYPE":
configType = value;
break;
case "TOKENS":
tokenPath = value;
break;
default:
// show usage help
activityToRun = ActivityMode.ShowHelp;
break;
}
}
}
if (activityToRun == ActivityMode.ShowHelp)
{
// something wasn't right with the parameter inputs. return false and a null config.
wgConfig = new WebGreaseConfiguration();
}
else
{
if (!string.IsNullOrWhiteSpace(configFileName))
{
try
{
// use the config file as a base, and set overrides based on CLI input
wgConfig = new WebGreaseConfiguration(new FileInfo(configFileName), configType, inputPath, outputPath, logPath);
}
catch (Exception ex)
{
HandleError(ex, null, ResourceStrings.ConfigurationFileParseError);
wgConfig = new WebGreaseConfiguration(configType);
return(ActivityMode.ShowHelp);
}
}
else
{
// manual build up of configuration data
wgConfig = new WebGreaseConfiguration(configType);
// initialize these to the current directory. Manual CLI paramters (not config files), will have their relative paths
// computed into the generated input specs.
wgConfig.SourceDirectory = Environment.CurrentDirectory;
wgConfig.DestinationDirectory = Environment.CurrentDirectory;
AddInputSpecs(wgConfig, inputPath, outputPath);
}
wgConfig = OverrideConfig(wgConfig, logPath, tokenPath, imagePath);
}
return(activityToRun);
}