/// <summary>
/// Validates the specified project items using JSLint.
/// </summary>
/// <param name="projectItems">The project items.</param>
/// <param name="settings">The settings.</param>
/// <returns>
/// The total number of JSLint errors found.
/// </returns>
public int LintProjectItems(IList <ProjectItem> projectItems, JSLintNetSettings settings)
{
if (projectItems.Count < 1)
{
return(0);
}
var hierarchy = this.GetHierarchy(projectItems[0].ContainingProject);
var errors = 0;
var files = 0;
var errorFiles = 0;
var exceptions = 0;
var errorLimit = settings.ErrorLimitOrDefault();
var filesLimit = settings.FileLimitOrDefault();
using (var jsLintContext = this.jsLintFactory())
{
foreach (var item in projectItems)
{
var fileName = item.Access().FileName;
this.errorListProvider.ClearJSLintErrors(fileName);
var isOpen = item.Document != null;
var result = ExecutionHelper.Try(() =>
{
string source;
if (isOpen)
{
source = item.Document.Access().Source;
}
else
{
source = this.fileSystemWrapper.ReadAllText(fileName, Encoding.UTF8);
}
return(jsLintContext.Lint(source, settings.Options, settings.GlobalVariables));
});
if (result.Success)
{
var data = result.Data;
if (data.Warnings.Count > 0)
{
errors += data.Warnings.Count;
errorFiles += 1;
this.errorListProvider.AddJSLintErrors(fileName, data.Warnings, settings.Output, hierarchy);
if (errors >= errorLimit)
{
this.errorListProvider.AddCustomError(CoreResources.ErrorLimitReachedFormat, errors);
break;
}
}
}
else
{
var ex = result.Exception;
this.errorListProvider.AddCustomError(CoreResources.ProcessingExceptionFormat, fileName, ex.Message);
exceptions += 1;
if (exceptions >= JSLintNetSettings.ExceptionLimit)
{
this.errorListProvider.AddCustomError(CoreResources.ExceptionLimitReachedFormat, exceptions);
break;
}
}
files += 1;
if (files >= filesLimit)
{
this.errorListProvider.AddCustomError(CoreResources.FileLimitReachedFormat, files);
break;
}
}
}
var text = GetMessageText(projectItems.Count, errorFiles, errors);
this.SetStatusBar(text);
return(errors);
}
/// <summary>
/// Executes the task.
/// </summary>
/// <returns>
/// <c>true</c> if the task successfully executed; otherwise, <c>false</c>.
/// </returns>
public override bool Execute()
{
var settings = this.LoadSettings();
var sourceFiles = this.GetSourceFiles(settings);
var output = settings.Output.GetValueOrDefault();
if (sourceFiles.Count > 0)
{
var logger = this.GetLogger(output);
var errorLimit = settings.ErrorLimitOrDefault();
var fileLimit = settings.FileLimitOrDefault();
var exceptions = 0;
var reportBuilder = new JSLintReportBuilder();
using (var context = this.jsLintFactory())
{
reportBuilder.SourceDirectory = this.SourceDirectory;
reportBuilder.AddSettings(settings.Files);
foreach (var file in sourceFiles)
{
var result = ExecutionHelper.Try(() =>
{
var source = this.fileSystemWrapper.ReadAllText(file.Absolute, Encoding.UTF8);
return(context.Lint(source, settings.Options, settings.GlobalVariables));
});
if (result.Success)
{
var data = result.Data;
reportBuilder.AddFile(file.Virtual, data);
foreach (var error in data.Warnings)
{
logger(
subcategory: AssemblyInfo.Product,
errorCode: null,
helpKeyword: null,
file: file.Absolute,
lineNumber: error.Line + 1,
columnNumber: error.Column + 1,
endLineNumber: 0,
endColumnNumber: 0,
message: string.Concat(Resources.ErrorTextPrefix, error.Message));
}
if (reportBuilder.ErrorCount >= errorLimit)
{
this.Log.LogError(Resources.ErrorLimitReachedFormat, reportBuilder.ErrorCount);
break;
}
}
else
{
this.Log.LogError(
Resources.ErrorEncounteredFormat,
file.Virtual,
Environment.NewLine,
result.Exception.Message);
exceptions += 1;
if (exceptions >= JSLintNetSettings.ExceptionLimit)
{
this.Log.LogError(Resources.ExceptionLimitReachedFormat, exceptions);
break;
}
}
if (reportBuilder.ProcessedFileCount >= fileLimit)
{
this.Log.LogError(Resources.FileLimitReachedFormat, reportBuilder.ProcessedFileCount);
break;
}
}
var reportFile = this.ReportFile;
if (!string.IsNullOrEmpty(reportFile))
{
if (!Path.IsPathRooted(reportFile))
{
reportFile = Path.Combine(this.SourceDirectory, reportFile);
}
this.fileSystemWrapper.WriteAllText(reportFile, reportBuilder.ToString(), Encoding.UTF8);
}
this.ErrorCount = reportBuilder.ErrorCount;
this.ErrorFileCount = reportBuilder.ErrorFileCount;
this.ProcessedFileCount = reportBuilder.ProcessedFileCount;
}
}
else
{
this.ErrorCount = 0;
this.ErrorFileCount = 0;
this.ProcessedFileCount = 0;
}
return(output != Output.Error || this.ErrorCount == 0);
}
public int Lint(ConsoleOptions options)
{
var sourceDirectory = options.SourceDirectory;
var settings = this.settingRepository.Load(options.SettingsFile);
var ignored = settings.NormalizeIgnore();
var sourceFiles = options.SourceFiles.Where(x => JSLint.CanLint(x) && !IsIgnored(sourceDirectory, x, ignored)).ToArray();
var errorLimit = settings.ErrorLimitOrDefault();
var fileLimit = settings.FileLimitOrDefault();
var exceptions = 0;
using (var context = this.jsLintFactory.CreateContext())
using (var reportBuilder = this.jsLintFactory.CreateReportBuilder())
{
reportBuilder.SourceDirectory = sourceDirectory;
reportBuilder.AddSettings(settings.Files);
foreach (var file in sourceFiles)
{
var relative = GetRelativePath(sourceDirectory, file);
var result = ExecutionHelper.Try(() =>
{
var source = this.fileSystemWrapper.ReadAllText(file, Encoding.UTF8);
return(context.Lint(source, settings.Options));
});
if (result.Success)
{
var data = result.Data;
var count = data.Errors.Count;
reportBuilder.AddFile(relative, data);
if (count > 0 && options.LogLevel == LogLevel.Verbose)
{
this.consoleWriter
.WriteErrorLine()
.WriteErrorLine(Resources.ErrorFileSummaryFormat, relative, count);
foreach (var error in data.Errors)
{
this.consoleWriter
.WriteErrorLine(4, Resources.ErrorItemFormat, error.Reason, error.Line, error.Character);
}
}
if (reportBuilder.ErrorCount >= errorLimit)
{
this.consoleWriter
.WriteErrorLine()
.WriteErrorLine(CoreResources.ErrorLimitReachedFormat, reportBuilder.ErrorCount);
break;
}
}
else
{
var ex = result.Exception;
this.consoleWriter
.WriteErrorLine()
.WriteErrorLine(Resources.ExceptionFileFormat, relative)
.WriteErrorLine(ex.Message);
exceptions += 1;
if (exceptions >= JSLintNetSettings.ExceptionLimit)
{
this.consoleWriter
.WriteErrorLine()
.WriteErrorLine(CoreResources.ExceptionLimitReachedFormat, exceptions);
break;
}
}
if (reportBuilder.ProcessedFileCount >= fileLimit)
{
this.consoleWriter
.WriteErrorLine()
.WriteErrorLine(CoreResources.FileLimitReachedFormat, reportBuilder.ProcessedFileCount);
break;
}
}
if (options.LogLevel != LogLevel.Silent)
{
this.consoleWriter
.WriteLine()
.WriteLine(Resources.SummarySourceDirectoryFormat, reportBuilder.SourceDirectory)
.WriteLine(Resources.SummarySettingsFileFormat, string.Join(", ", reportBuilder.SettingsFiles))
.WriteLine(Resources.SummaryProcessedFileCountFormat, reportBuilder.ProcessedFileCount)
.WriteLine(Resources.SummaryErrorFileCountFormat, reportBuilder.ErrorFileCount)
.WriteLine(Resources.SummaryErrorCountFormat, reportBuilder.ErrorCount);
}
if (!string.IsNullOrEmpty(options.ReportFile))
{
this.fileSystemWrapper.WriteAllText(options.ReportFile, reportBuilder.ToString(), Encoding.UTF8);
}
return(reportBuilder.ErrorCount);
}
}
