public Documenter(IFileLoader fl, ISourceCodeParser dp, IDocGenerator gen, IOutputWriter ow, ILogger <Documenter> logger)
{
this.loader = fl;
this.parser = dp;
this.generator = gen;
this.writer = ow;
this.OutputDocs = null;
this.logger = logger;
}
public Befunge93Context(ISourceCodeParser parser) : base(SupportedCommands, parser)
{
for (var i = 0; i < _field.GetLength(0); i++)
{
for (var j = 0; j < _field.GetLength(1); j++)
{
_field[i, j] = ' ';
}
}
}
private void CreateParser(ISourceCodeParser codeParser)
{
if (customLogger == null)
{
var logger = Mock.Of <ILogger>();
_parser = new Parser(codeParser, logger);
}
else
{
_parser = new Parser(codeParser, customLogger);
}
}
/// <summary>
/// Tests whether a class diagram generated from <paramref name="inputCode"/> contains all <paramref name="expectedLines"/>.
/// (It's order does not matter)
/// <para>This test method does not confirm that generated diagram constains unexpected lines.</para>
/// <para>It searches expected texts with ignoring space characters.</para>
/// </summary>
/// <param name="parser">Parser to parse <paramref name="inputCode"/></param>
/// <param name="inputCode">Input source code text to generate a class diagram</param>
/// <param name="expectedLines">Text lines which is expected to be included in a generated class diagram</param>
/// <param name="expectedIgnoreLines">Text lines which is expected to be included as commented line in a generated class diagram</param>
/// <param name="accessFilter">Access level filter</param>
/// <param name="excludedClasses">Class names to be excluded in a diagram (actually they are included as commented lines in a diagram)</param>
private static void TestcaseGenerate(ISourceCodeParser parser,
string inputCode,
IEnumerable <string> expectedLines,
IEnumerable <string> expectedIgnoreLines = null,
Modifier accessFilter = Modifiers.AllAccessLevels,
IEnumerable <string> excludedClasses = null)
{
var title = "test_title";
var classes = parser.Parse(inputCode);
var relations = RelationFactory.CreateFromClasses(classes);
var diag = PumlClassDiagramGenerator.Generate(title, classes, relations, accessFilter, excludedClasses);
diag = Regex.Replace(diag, "\\s+", string.Empty);
var emptyDiag = PumlClassDiagramGenerator.Generate(title, null, null);
var emptyDiagLines = emptyDiag.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => Regex.Replace(s, "\\s+", string.Empty));
var allExpLines = expectedLines
.Concat(emptyDiagLines) // To check common lines
.Concat(expectedIgnoreLines?.Select(s => CommentSymbol + s) ?? Enumerable.Empty <string>())
.Select(s => Regex.Replace(s, "\\s+", string.Empty));
foreach (var line in allExpLines)
{
// It is OK, if one of patterns generated from a expected line matches a part of input code.
var patterns = CreatePatterns(line);
var matchedPattern = patterns.Where(p => diag.IndexOf(p) >= 0).FirstOrDefault();
if (matchedPattern == null)
{
Console.WriteLine(diag);
AssertEx.Fail($"Expected '{line}' is contained in a generated class diagram"
+ $", but actual diagram does not contain it.");
}
diag = diag.Remove(diag.IndexOf(matchedPattern), matchedPattern.Length);
}
// Remove comment symbol attached to bracket.
diag = diag.Replace($"{CommentSymbol}{{", "{").Replace($"{CommentSymbol}}}", "}");
// If all texts are checked, diag is expected to contain only symbols.
Regex.IsMatch(diag, "^[\\s{}]*$").IsTrue($"Unexpected lines are contained {diag}");
}
protected FungeFamilyLanguage(FungeContext executionContext, CommandProducer commandProducer, ISourceCodeParser parser)
{
_executionContext = executionContext;
_commandProducer = commandProducer;
_parser = parser;
}
public Befunge_93(CommandProducer commandProducer, ISourceCodeParser parser) : base(new Befunge93Context(parser), commandProducer)
{
}
protected FungeContext(HashSet <char> supportedCommands1, ISourceCodeParser parser)
{
_stacks.Push(new Stack <int>());
_supportedCommands = supportedCommands1;
Parser = parser;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="parser">Parser to parse this language's source codes</param>
/// <param name="extension">File extension of this language</param>
/// <param name="cmdValues">Command argument values that specifies this language</param>
public Language(ISourceCodeParser parser, string extension, IEnumerable <string> cmdValues)
{
this.Parser = parser;
this.Extension = extension;
this.CmdValues = cmdValues.Select(s => s.ToLower());
}
/// <summary>
/// Generates a class diagram.
/// </summary>
/// <param name="title">Title of class diagram</param>
/// <param name="filePaths">Source code paths</param>
/// <param name="parser">Parser to parse source codes</param>
/// <param name="accessLevel">Access level of members written to a class diagram</param>
/// <param name="excludedClasses">A collection of class names not to be written to a class diagram</param>
/// <returns>Class diagram described in PlantUML</returns>
private static string GenerateClassDiagram(string title, IEnumerable <string> filePaths, ISourceCodeParser parser, Modifier accessLevel, IEnumerable <string> excludedClasses)
{
var classes = new List <ClassInfo>();
foreach (var file in filePaths)
{
try
{
var content = File.ReadAllText(file);
classes.AddRange(parser.Parse(content));
}
catch
{
Console.Error.WriteLine($"Skipped (could not open file) : {file}");
}
}
Console.WriteLine($"Parsed classes ... {classes.Count}");
var relations = RelationFactory.CreateFromClasses(classes);
return(PumlClassDiagramGenerator.Generate(title ?? string.Empty, classes, relations, accessLevel, excludedClasses));
}
public Parser(ISourceCodeParser codeParser, ILogger logger, int threadCount = 8)
{
this.codeParser = codeParser;
this.logger = logger;
this.semaphore = new SemaphoreSlim(threadCount, threadCount);
}
public ParserContext SetStratagy(ISourceCodeParser parseStrategy)
{
this.parser = parseStrategy ?? throw new ArgumentNullException("parseStrategy is null");
return(this);
}
public ParserContext(ISourceCodeParser parseStrategy)
{
this.parser = parseStrategy;
}
