Esempio n. 1
0
        public void LoadLinesOfCode()
        {
            LoadLinesOfCodeForModule(_module);

            if (_countSubmodules)
            {
                var submodules = _module.GetSubmodulesInfo()
                                 .Select(submodule => new VsrModule(Path.Combine(_module.WorkingDir, submodule.LocalPath)));

                foreach (var submodule in submodules)
                {
                    LoadLinesOfCodeForModule(submodule);
                }
            }

            // Send 'changed' event when done
            OnLineCounterUpdated(_lineCounter, EventArgs.Empty);

            return;

            void LoadLinesOfCodeForModule(IVsrModule module)
            {
                var filesToCheck = module
                                   .GetTree(module.RevParse("HEAD"), full: true)
                                   .Select(file => Path.Combine(module.WorkingDir, file.Name))
                                   .ToList();

                _lineCounter.FindAndAnalyzeCodeFiles(_codeFilePattern, DirectoriesToIgnore, filesToCheck);
            }
        }
        private void LoadLinesOfCodeForModule(IGitModule module)
        {
            var result = module.GetTree("HEAD", full: true);
            var filesToCheck = new List<string>();
            filesToCheck.AddRange(result.Select(file => Path.Combine(module.WorkingDir, file.Name)));

            _lineCounter.FindAndAnalyzeCodeFiles(_codeFilePattern, DirectoriesToIgnore, filesToCheck);
        }
Esempio n. 3
0
        private void LoadLinesOfCodeForModule(IGitModule module)
        {
            var result       = module.RunGitCmd("ls-files");
            var filesToCheck = new List <string>();

            if (!string.IsNullOrWhiteSpace(result))
            {
                filesToCheck.AddRange(result.Split('\n')
                                      .Select(file => Path.Combine(module.WorkingDir, file)));
            }

            _lineCounter.FindAndAnalyzeCodeFiles(_codeFilePattern, DirectoriesToIgnore, filesToCheck);
        }
Esempio n. 4
0
 public void LoadLinesOfCode()
 {
     lineCounter.FindAndAnalyzeCodeFiles(_codeFilePattern, DirectoriesToIgnore);
 }
        private void InitializeLinesOfCode()
        {
            var lineCounter = new LineCounter(WorkingDir);

            lineCounter.FindAndAnalyzeCodeFiles(_codeFilePattern, DirectoriesToIgnore);

            TotalLinesOfTestCode.Text = lineCounter.NumberTestCodeLines + " Lines of test code";

            TestCodePie.SetValues(new Decimal[]
                                      {
                                          lineCounter.NumberTestCodeLines,
                                          lineCounter.NumberCodeLines - lineCounter.NumberTestCodeLines
                                      });
            TestCodePie.ToolTips =
                new[]
                    {
                        lineCounter.NumberTestCodeLines + " Lines of testcode",
                        lineCounter.NumberCodeLines - lineCounter.NumberTestCodeLines +
                        " Lines of production code"
                    };

            TestCodeText.Text = lineCounter.NumberTestCodeLines + " Lines of testcode" + Environment.NewLine +
                                (lineCounter.NumberCodeLines - lineCounter.NumberTestCodeLines) +
                                " Lines of production code";

            LinesOfCodePie.SetValues(new Decimal[]
                                         {
                                             lineCounter.NumberBlankLines,
                                             lineCounter.NumberCommentsLines,
                                             lineCounter.NumberLines,
                                             lineCounter.NumberLinesInDesignerFiles
                                         });
            LinesOfCodePie.ToolTips =
                new[]
                    {
                        lineCounter.NumberBlankLines + " Blank lines",
                        lineCounter.NumberCommentsLines + " Comment lines",
                        lineCounter.NumberCodeLines + " Lines of code",
                        lineCounter.NumberLinesInDesignerFiles + " Lines in designer files"
                    };

            LinesOfCodePerTypeText.Text = LinesOfCodePie.ToolTips[0] + Environment.NewLine;
            LinesOfCodePerTypeText.Text += LinesOfCodePie.ToolTips[1] + Environment.NewLine;
            LinesOfCodePerTypeText.Text += LinesOfCodePie.ToolTips[2] + Environment.NewLine;
            LinesOfCodePerTypeText.Text += LinesOfCodePie.ToolTips[3] + Environment.NewLine;

            var extensionValues = new Decimal[lineCounter.LinesOfCodePerExtension.Count];
            var extensionLabels = new string[lineCounter.LinesOfCodePerExtension.Count];
            var n = 0;
            LinesOfCodePerLanguageText.Text = "";
            foreach (var keyValuePair in lineCounter.LinesOfCodePerExtension)
            {
                LinesOfCodePerLanguageText.Text += keyValuePair.Value + " Lines of code in " + keyValuePair.Key +
                                                   " files" + Environment.NewLine;
                extensionValues[n] = keyValuePair.Value;
                extensionLabels[n] = keyValuePair.Value + " Lines of code in " + keyValuePair.Key + " files";
                n++;
            }

            LinesOfCodeExtensionPie.SetValues(extensionValues);
            LinesOfCodeExtensionPie.ToolTips = extensionLabels;

            TotalLinesOfCode2.Text = TotalLinesOfCode.Text = lineCounter.NumberCodeLines + " Lines of code";
        }