Ejemplo n.º 1
0
        private void OnBeforeCodeWindowGenerateProperty(object sender, EventArgs e)
        {
            var menuCommand = (OleMenuCommand)sender;
            var document    = this.Environment.ActiveDocument;

            menuCommand.Visible = document != null && JSLint.IsJavaScript(document.Name);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Normalizes the ignore list to a new clone.
        /// </summary>
        /// <returns>A normalized clone of the ignore list.</returns>
        public IList <string> NormalizeIgnore()
        {
            var clone = new List <string>();

            if (this.Ignore != null)
            {
                var directorySeparator = Path.DirectorySeparatorChar.ToString();

                for (int i = 0; i < this.Ignore.Count; i++)
                {
                    var normalized = this.Ignore[i];

                    normalized = normalized.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);

                    if (!normalized.StartsWith(directorySeparator))
                    {
                        normalized = directorySeparator + normalized;
                    }

                    if (!JSLint.CanLint(normalized) && !normalized.EndsWith(directorySeparator))
                    {
                        normalized += directorySeparator;
                    }

                    clone.Add(normalized);
                }
            }

            return(clone);
        }
Ejemplo n.º 3
0
        private void OnBeforeCodeWindowRun(object sender, EventArgs e)
        {
            var menuCommand = (OleMenuCommand)sender;
            var document    = this.Environment.ActiveDocument;

            menuCommand.Visible = document != null && JSLint.CanLint(document.Name);
        }
Ejemplo n.º 4
0
        private bool IsSelectionLintable()
        {
            var selectedItems = this.Environment.SelectedItems;

            return(selectedItems.Count > 0 &&
                   selectedItems
                   .OfType <SelectedItem>()
                   .All(x => JSLint.CanLint(x.Name)));
        }
Ejemplo n.º 5
0
        private void OnCodeWindowGenerateProperty(object sender, EventArgs e)
        {
            var document = this.Environment.ActiveDocument;

            if (document != null && JSLint.CanLint(document.Name))
            {
                this.VisualStudioJSLintProvider.GeneratePropertyDirective(document);
            }
        }
Ejemplo n.º 6
0
        private void OnBeforeItemNodeIgnore(object sender, EventArgs e)
        {
            var menuCommand = (OleMenuCommand)sender;
            var selections  = this.Environment.SelectedItems;

            menuCommand.Visible = selections.Count == 1 && JSLint.CanLint(selections.Item(1).Name);

            this.SetIgnoreMenuItemState(menuCommand, selections);
        }
Ejemplo n.º 7
0
        private void OnDocumentSaved(Document document)
        {
            if (JSLint.CanLint(document.Name))
            {
                var settings = this.VisualStudioJSLintProvider.LoadSettings(document.ProjectItem.ContainingProject);
                var ignored  = settings.NormalizeIgnore();

                if (settings.RunOnSave.GetValueOrDefault() && !document.ProjectItem.Is().Ignored(ignored))
                {
                    this.VisualStudioJSLintProvider.LintDocument(document, settings);
                }
            }
        }
Ejemplo n.º 8
0
        public ITagger <T> CreateTagger <T>(ITextBuffer buffer)
            where T : ITag
        {
            var doc = GetBufferProperty <ITextDocument>(buffer);

            if (doc != null)
            {
                var fileName = doc.FilePath;

                if (JSLint.CanLint(fileName))
                {
                    return(buffer.Properties.GetOrCreateSingletonProperty(() => (ITagger <T>) new JSLintTagger(buffer, this.ErrorListProvider, fileName)));
                }
            }

            return(null);
        }
Ejemplo n.º 9
0
        private static void AddLintable(ProjectItem projectItem, List <ProjectItem> projectItemList, IList <string> ignore)
        {
            var fileName = projectItem.Access().FileName;

            if (!projectItem.Is().Folder)
            {
                if (JSLint.CanLint(fileName) && !projectItem.Is().Ignored(ignore))
                {
                    projectItemList.Add(projectItem);
                }

                return;
            }

            foreach (ProjectItem subItem in projectItem.ProjectItems)
            {
                AddLintable(subItem, projectItemList, ignore);
            }
        }
Ejemplo n.º 10
0
        private IList <ProjectItem> SelectedLintables()
        {
            var selectedItems = this.Environment.SelectedItems;
            var projectItems  = new List <ProjectItem>();

            foreach (SelectedItem selectedItem in selectedItems)
            {
                if (JSLint.CanLint(selectedItem.Name))
                {
                    var projectItem = selectedItem.ProjectItem;

                    if (projectItem != null)
                    {
                        projectItems.Add(projectItem);
                    }
                }
            }

            return(projectItems);
        }
Ejemplo n.º 11
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);
                }
        }