public UmlToolWindowViewModel()
{
ThreadHelper.ThrowIfNotOnUIThread();
try
{
var fileCode = GetFileContent();
if (fileCode.Equals(string.Empty))
{
return;
}
var classCode = ClassParser.Parse(fileCode);
var plantCode = UmlRenderer.Render(classCode);
var renderFactory = new PlantUml.Net.RendererFactory();
var plantUmlRenderer = renderFactory.CreateRenderer();
using (var mStream = new MemoryStream(plantUmlRenderer.Render(plantCode, OutputFormat.Png)))
{
UmlOutput = BitmapFrame.Create(mStream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
}
}
catch (HttpRequestException e)
{
Console.WriteLine(e);
}
}
public void SingleClass_Fail_NoStructureType()
{
var target = new ClassParser();
var result = target.Parse("public MyClass { }");
result.Should().BeNull();
}
private void ReadJar()
{
using var ms = new MemoryStream(RawContents);
var archive = new ZipArchive(ms);
foreach (var javaClass in archive.Entries
.Where(c => Path.GetExtension(c.Name).ToLower() == ".class")
.Select(e =>
{
//Let NBCEL parse the class file
var reader = new ClassParser(e.Open().ReadFully(), e.Name);
var result = reader.Parse();
var ownJavaClass = new JavaClass(result);
//Store the class for future use from NBCEL.
SyntheticRepository.GetInstance().StoreClass(result);
LoadedClassRepository.Instance.StoreClass(ownJavaClass);
return(ownJavaClass);
}
))
{
Classes.Add(javaClass.FullClassName, javaClass);
}
}
public void NestedClasses_Success()
{
var target = new ClassParser();
var c1 = target.Parse(@"
public class MyClass1 {
private struct MyClass2 {
internal interface MyClass3 {
}
}
}");
c1.Should().NotBeNull();
c1.AccessModifier.Should().Be("public");
c1.StructureType.Should().Be("class");
c1.Name.Should().Be("MyClass1");
c1.Children.Count.Should().Be(1);
var c2 = c1.Children[0];
c2.Should().NotBeNull();
c2.AccessModifier.Should().Be("private");
c2.StructureType.Should().Be("struct");
c2.Name.Should().Be("MyClass2");
c2.Children.Count.Should().Be(1);
var c3 = c2.Children[0];
c3.Should().NotBeNull();
c3.AccessModifier.Should().Be("internal");
c3.StructureType.Should().Be("interface");
c3.Name.Should().Be("MyClass3");
c3.Children.Count.Should().Be(0);
}
public void SingleClass_Fail_AccessModifierSecond()
{
var target = new ClassParser();
var result = target.Parse("class public MyClass { }");
result.Should().BeNull();
}
// [DebuggerStepThrough]
public void Parse(string s)
{
// replace disturbing chars
string src = s.Replace("\n", "");
src = src.Replace("\t", "");
src = Regex.Replace(src, "~.+~", ""); // remove comments
// transform source
string[] cmdss = src.Split(Convert.ToChar("{"));
src = src.Remove(0, cmdss[0].Length + 1);
src = src.Remove(src.Length - 2, 2);
src = src.Replace("}", "\n");
UseStatementParser.Parse(cmdss[0], this);
//parsing commands
foreach (string cm in src.Split(Convert.ToChar("\n")))
{
var sh = BlockHeaderParser.Parse(cm.Split(Convert.ToChar("{"))[0]);
var cmd = new Section {
Header = { Name = sh.Name }
};
VarDefParser.Parse(DataTypes, cm, cmd);
FunctionCallParser.Parse(cm, cmd, this);
VarSetParser.Parse(DataTypes, cm, cmd);
ClassParser.Parse(cm, this);
Sections.Add(cmd);
}
}
public void InterfacesMayNotContainChildren()
{
var target = new ClassParser();
var c1 = target.Parse(@"
public interface Interface1 {
private class MyClass2 {
}
}");
c1.Should().BeNull();
}
public void SingleClass_Success()
{
var target = new ClassParser();
var result = target.Parse("public class MyClass { }");
result.Should().NotBeNull();
result.AccessModifier.Should().Be("public");
result.StructureType.Should().Be("class");
result.Name.Should().Be("MyClass");
result.Children.Count.Should().Be(0);
}
public void SingleClass_Fail_NoAccessModifier()
{
// Unfortunately there is no good way, that I am aware of, for the parser to
// determine that a certain prefix is mandatory. Unfortuately this test will have to
// just stay as a reminder.
var target = new ClassParser();
var result = target.Parse("class MyClass { }");
result.Should().NotBeNull();
result.AccessModifier.Should().BeNull();
// result.Should().BeNull();
}
private void ProcessClassElement(ClassElement c, Dictionary <string, Package> derivationSuppliers)
{
if (c.Choice is MohawkCollege.EHR.HL7v3.MIF.MIF20.StaticModel.Flat.Class) // todo: Finish this with CMET and Template Parameter
{
ClassParser.ClassParameterInfo pi = new ClassParser.ClassParameterInfo();
pi.Class = c.Choice as MohawkCollege.EHR.HL7v3.MIF.MIF20.StaticModel.Flat.Class;
pi.CompilerRepository = ClassRepository;
pi.DerivationSuppliers = derivationSuppliers;
pi.MifContainer = this.staticModel;
pi.ScopedPackageName = staticModel.PackageLocation.Artifact == ArtifactKind.RIM ? "RIM" : staticModel.PackageLocation.ToString(MifCompiler.NAME_FORMAT);
ClassParser.Parse(pi);
}
else if (c.Choice is StaticModelClassTemplateParameter)
{
TypeParameter parm = TypeParameterParser.Parse(c.Choice as StaticModelClassTemplateParameter);
templateParameters.Add(parm.ParameterName, parm);
}
else if (c.Choice is CommonModelElementRef)
{
// Process a common model element reference
CommonModelElementRef cmetRef = c.Choice as CommonModelElementRef;
}
}
