public void GetUrl_GivenBlock00XXCode_ProperlyBuildsUrl(AnalyzerBlock analyzerBlock, string code,
                                                                string expected)
        {
            string actual = DiagnosticUrlBuilder.GetUrl(analyzerBlock, code);

            Assert.IsTrue(string.Equals(expected, actual, StringComparison.OrdinalIgnoreCase),
                          $"'{expected}' does not equal '{actual}'");
        }
        public static string GetDescription(this AnalyzerBlock value)
        {
            if (value == AnalyzerBlock.None)
            {
                throw new ArgumentException("AnalyzerBlock must be specified", nameof(value));
            }

            return(GetEnumAttributeValue <DescriptionAttribute>(value, x => x.Description));
        }
 public static string GetUrl(AnalyzerBlock analyzerBlock, string intlCode)
 {
     return(BaseUrl + analyzerBlock.GetDescription() + $"#{intlCode}");
 }
        public IEnumerable <AnalyzerItem> AnalyzeSource(string source)
        {
            List <AnalyzerBlock> blockStack = new List <AnalyzerBlock>();
            var lines = source.Split("\r\n")
                        .SelectMany(x => x.Split("\n"))
                        .Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();

            for (int i = 0; i < lines.Length; i++)
            {
                if (lines[i].TrimStart().StartsWith("//") || lines[i].TrimStart().StartsWith("/*"))
                {
                    continue;
                }
                var line    = lines[i].Split('\t', ' ', '(', ')', '+', ',', '-', '*', '/');
                var matches = startProcedure.Matches(lines[i]);
                var last    = blockStack.LastOrDefault();
                if (line.Contains("if"))
                {
                    var block = new AnalyzerBlock
                    {
                        BranchType = BranchType.If,
                        LineNumber = i
                    };
                    blockStack.Add(block);
                    yield return(new AnalyzerItem {
                        BranchType = BranchType.If, LineNumber = i
                    });
                }
                else if (line.Contains("for"))
                {
                    var block = new AnalyzerBlock
                    {
                        BranchType = BranchType.ForOrWhile,
                        LineNumber = i
                    };
                    blockStack.Add(block);
                    yield return(new AnalyzerItem {
                        BranchType = BranchType.ForOrWhile, LineNumber = i, Comment = "for"
                    });
                }

                else if (line.Contains("while"))
                {
                    var block = new AnalyzerBlock
                    {
                        BranchType = BranchType.ForOrWhile,
                        LineNumber = i
                    };
                    blockStack.Add(block);
                    yield return(new AnalyzerItem {
                        BranchType = BranchType.ForOrWhile, LineNumber = i, Comment = "while"
                    });
                }
                else if (matches.Count > 0)
                {
                    if (matches[0].Groups?[8]?.Value == "new")
                    {
                        continue;
                    }
                    var block = new AnalyzerBlock
                    {
                        IsStart    = true,
                        LineNumber = i
                    };
                    blockStack.Add(block);
                    yield return(new AnalyzerItem {
                        IsProcedure = true, LineNumber = i, Comment = matches[0].Groups?[9]?.Value ?? String.Empty
                    });
                }
                else if (line.Contains("do"))
                {
                    var block = new AnalyzerBlock
                    {
                        BranchType = BranchType.DoWhile,
                        LineNumber = i
                    };
                    blockStack.Add(block);
                    yield return(new AnalyzerItem {
                        BranchType = BranchType.DoWhile, LineNumber = i
                    });
                }
                else if (line.Contains("{"))
                {
                    if (last == null || last.IsStart == false && last.BranchType == BranchType.None)
                    {
                        blockStack.Add(new AnalyzerBlock()
                        {
                            LineNumber = i
                        });
                    }
                }
                else if (line.Contains("}"))
                {
                    if (last != null)
                    {
                        blockStack.Remove(last);
                        if (last.BranchType == BranchType.If)
                        {
                            if (lines[i + 1].Contains("else"))
                            {
                                i++;
                                blockStack.Add(new AnalyzerBlock()
                                {
                                    BranchType        = BranchType.Else,
                                    LineNumber        = i,
                                    ConnectedFromLine = new List <int>()
                                    {
                                        last.LineNumber
                                    }
                                });
                                yield return(new AnalyzerItem()
                                {
                                    BranchType = BranchType.Else,
                                    LineNumber = i,
                                    ConnectedFrom = new List <int>()
                                    {
                                        last.LineNumber
                                    }
                                });
                            }
                            else
                            {
                                yield return(new AnalyzerItem()
                                {
                                    BranchType = BranchType.IfEnd,
                                    LineNumber = i,
                                    ConnectedFrom = new List <int>()
                                    {
                                        last.LineNumber, last.LineNumber
                                    }
                                });
                            }
                        }
                        else if (last.BranchType == BranchType.DoWhile)
                        {
                            if (lines[i + 1].Contains("while"))
                            {
                                i++;
                                yield return(new AnalyzerItem
                                {
                                    BranchType = BranchType.DoWhileEnd, LineNumber = i,
                                    ConnectedFrom = new List <int> {
                                        last.LineNumber
                                    },
                                    Comment = "while"
                                });
                            }
                        }
                        else if (last.BranchType == BranchType.Else)
                        {
                            yield return(new AnalyzerItem()
                            {
                                BranchType = BranchType.IfEnd,
                                LineNumber = i,
                                ConnectedFrom = new List <int>()
                                {
                                    last.LineNumber, last.ConnectedFromLine[0]
                                }
                            });
                        }
                        else if (last.BranchType == BranchType.ForOrWhile)
                        {
                            yield return(new AnalyzerItem()
                            {
                                BranchType = BranchType.ForOrWhileEnd,
                                LineNumber = i,
                                ConnectedFrom = new List <int>()
                                {
                                    last.LineNumber, last.LineNumber
                                }
                            });
                        }
                        else if (last.IsStart)
                        {
                            yield return(new AnalyzerItem()
                            {
                                LineNumber = i,
                                IsProcedure = false,
                            });
                        }
                    }
                }
            }
        }