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;
            var reportBuilder = new JSLintReportBuilder();

            using (var context = this.jsLintFactory())
            {
                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, settings.GlobalVariables);
                    });

                    if (result.Success)
                    {
                        var data = result.Data;
                        var count = data.Warnings.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.Warnings)
                            {
                                this.consoleWriter
                                    .WriteErrorLine(4, Resources.ErrorItemFormat, error.Message, error.Line + 1, error.Column + 1);
                            }
                        }

                        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;
            }
        }
Exemple #2
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;
            var reportBuilder   = new JSLintReportBuilder();

            using (var context = this.jsLintFactory())
            {
                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, settings.GlobalVariables));
                    });

                    if (result.Success)
                    {
                        var data  = result.Data;
                        var count = data.Warnings.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.Warnings)
                            {
                                this.consoleWriter
                                .WriteErrorLine(4, Resources.ErrorItemFormat, error.Message, error.Line + 1, error.Column + 1);
                            }
                        }

                        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);
            }
        }