public void Test() { string codeText = File.ReadAllText("Resources\\BasicClass.txt"); var parser = new CSharpParser(); parser.ParseCode(codeText); var codeRoot = (CodeRoot)parser.CreatedCodeRoot; //Actions actions = Test2(codeRoot);//Test1(codeRoot); Actions actions = new Actions(); Entity entity = new EntityImpl("BasicClass"); entity.AddProperty(new PropertyImpl { Name = "Property5", Type = "Entity" }); Entity entity1 = new EntityImpl("Class1"); entity1.AddProperty(new PropertyImpl { Name = "Property5", Type = "Entity" }); entity.MappedClass = codeRoot.Namespaces[0].Classes[0]; entity1.MappedClass = codeRoot.Namespaces[0].Classes[1]; CheckEntity(entity, actions); codeText = actions.RunActions(codeText, codeRoot, true); actions = new Actions(); actions.AddAction(new AddAttributeToPropertyAction(entity.MappedClass.Properties[0], new Attribute(codeRoot.Controller){Name = "Attr"})); CheckEntity(entity1, actions); var output = actions.RunActions(codeText, codeRoot, false); }
public void TestPosition() { CSharpParser parser = new CSharpParser(); parser.ParseCode(@"using System; using NUnit.Framework; class Hahaha { "); Assert.That(parser.ErrorOccurred, Is.True); Assert.That(parser.SyntaxErrors, Has.Count(1)); Assert.That(parser.SyntaxErrors[0].LineNumber, Is.EqualTo(3)); parser = new CSharpParser(); parser.ParseCode(@"using System; using NUnit.Framework; class Hahaha { public TestMethod(){ }"); Assert.That(parser.ErrorOccurred, Is.True); Assert.That(parser.SyntaxErrors, Has.Count(1)); Assert.That(parser.SyntaxErrors[0].LineNumber, Is.EqualTo(4)); parser = new CSharpParser(); parser.ParseCode(@"using System"); Assert.That(parser.ErrorOccurred, Is.True); Assert.That(parser.SyntaxErrors, Has.Count(1)); Assert.That(parser.SyntaxErrors[0].LineNumber, Is.EqualTo(0)); }
public void testMultipleErrors() { CSharpParser parser = new CSharpParser(); parser.ParseCode(@"using System using NUnit.Framework; class Hahaha { publi TestMethod() { } }"); Assert.That(parser.ErrorOccurred, Is.True); Assert.That(parser.SyntaxErrors, Has.Count(2)); Assert.That(parser.SyntaxErrors[0].LineNumber, Is.EqualTo(0)); Assert.That(parser.SyntaxErrors[1].LineNumber, Is.EqualTo(4)); parser = new CSharpParser(); parser.ParseCode(@"using System using NUnit.Framework; class Hahaha { publi TestMethod() { } public testOtherMethod( { } }"); Assert.That(parser.ErrorOccurred, Is.True); Assert.That(parser.SyntaxErrors, Has.Count(3)); Assert.That(parser.SyntaxErrors[0].LineNumber, Is.EqualTo(0)); Assert.That(parser.SyntaxErrors[1].LineNumber, Is.EqualTo(4)); Assert.That(parser.SyntaxErrors[2].LineNumber, Is.EqualTo(8)); }
public void Attributes() { const string code = @" namespace n1 { [Serializable] [SomeAttribute(NamedParam = ""Nothing"")] public class Class1 { } [Positional(1, ""string"")] public class Class2 { } }"; CSharpParser parser = new CSharpParser(); parser.FormatSettings.ReorderBaseConstructs = false; parser.ParseCode(code); ICodeRoot codeRoot = parser.CreatedCodeRoot; Namespace n1 = (Namespace)codeRoot.WalkChildren()[0]; Class clazz = n1.Classes[0]; Assert.That(clazz.Attributes, Has.Count(2)); Assert.That(clazz.Attributes[0].ToString(), Is.EqualTo("Serializable")); Assert.That(clazz.Attributes[1].ToString(), Is.EqualTo("SomeAttribute(NamedParam = \"Nothing\")")); clazz = n1.Classes[1]; Assert.That(clazz.Attributes, Has.Count(1)); Assert.That(clazz.Attributes[0].ToString(), Is.EqualTo("Positional(1, \"string\")")); }
/// <summary> /// Parses the source-code in the csharpFileText. /// </summary> /// <param name="vbFileText"></param> /// <returns></returns> public static CodeRoot ParseVbCode(string vbFileText) { var parser = new CSharpParser(); var parseResults = new ParseResults(); parser.Reset(); parser.ParseCode(vbFileText); return (CodeRoot)parser.CreatedCodeRoot; }
public void Reparse() { ClearErrors(); CSharpParser formatter = new CSharpParser(); formatter.ParseCode(editor.Text); if(formatter.ErrorOccurred) { AddAllErrors(formatter.SyntaxErrors); } DisplayErrors(); }
public void TestBasicSyntaxError() { CSharpParser parser = new CSharpParser(); parser.ParseCode("using System;"); Assert.That(parser.ErrorOccurred, Is.False); parser = new CSharpParser(); parser.ParseCode("lkjakjlawel;rfjaolkjnawlekmfpijsdpv;je;kf23-54-9845emadvlz"); Assert.That(parser.ErrorOccurred, Is.True); Assert.That(parser.SyntaxErrors, Has.Count(1)); }
public void An_InterfaceEvent_Is_Created() { const string code = "event Delegate1 Event1;"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.InterfaceEventDeclaration); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(InterfaceEvent))); InterfaceEvent con = (InterfaceEvent)bc; Assert.That(con.Name, Is.EqualTo("Event1")); Assert.That(con.DataType.Name, Is.EqualTo("Delegate1")); }
public void Comments() { const string code = @" /// <summary> /// Xml Comment line\r\n /// break. ///</summary> public class Class1 // Class Trailing Comment { // Comment1-1 // Comment1-2 public int i = 0; // Trailing Comment // Comment2-1 public int j = 0; }"; CSharpParser parser = new CSharpParser(); parser.ParseCode(code); ICodeRoot codeRoot = parser.CreatedCodeRoot; Assert.That(codeRoot, Is.InstanceOfType(typeof (CodeRoot))); Assert.That(codeRoot.WalkChildren(), Has.Count(1)); Class clazz = (Class) codeRoot.WalkChildren()[0]; Assert.That(clazz, Is.Not.Null); Assert.That(clazz.Name, Is.EqualTo("Class1")); Assert.That(clazz.XmlComments, Has.Count(4)); Assert.That(clazz.XmlComments[0].Trim(), Is.EqualTo(@"<summary>")); Assert.That(clazz.XmlComments[1].Trim(), Is.EqualTo(@"Xml Comment line\r\n")); Assert.That(clazz.XmlComments[2].Trim(), Is.EqualTo(@"break.")); Assert.That(clazz.XmlComments[3].Trim(), Is.EqualTo(@"</summary>")); Assert.That(clazz.Comments.TrailingComment, Is.EqualTo("// Class Trailing Comment")); Assert.That(clazz.WalkChildren(), Has.Count(2)); Field field = (Field) clazz.WalkChildren()[0]; Assert.That(field.Name, Is.EqualTo("i")); Assert.That(field.Comments.PreceedingComments, Has.Count(2)); Assert.That(field.Comments.PreceedingComments[0], Is.EqualTo("// Comment1-1")); Assert.That(field.Comments.PreceedingComments[1], Is.EqualTo("// Comment1-2")); Assert.That(field.Comments.TrailingComment, Is.EqualTo("// Trailing Comment")); field = (Field)clazz.WalkChildren()[1]; Assert.That(field.Name, Is.EqualTo("j")); Assert.That(field.Comments.PreceedingComments, Has.Count(1)); Assert.That(field.Comments.PreceedingComments[0], Is.EqualTo("// Comment2-1")); }
public void Diff_Result_Is_Exact_Copy() { string original = Path.Combine(ResourcePath, "Class1.cs"); CodeRootMap codeRootMap = new CodeRootMap(); CSharpParser formatter = new CSharpParser(); formatter.ParseCode(File.ReadAllText(original)); ICodeRoot codeRoot = formatter.CreatedCodeRoot; codeRootMap.AddCodeRoot(codeRoot, Version.User); codeRootMap.AddCodeRoot(codeRoot, Version.NewGen); codeRootMap.AddCodeRoot(codeRoot, Version.PrevGen); Assert.That(codeRootMap.Diff(), Is.EqualTo(TypeOfDiff.ExactCopy)); }
public void An_Event_Is_Created() { const string code = "public event Delegate1 Event1;"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.EventDeclaration); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(Event))); Event con = (Event)bc; Assert.That(con.Name, Is.EqualTo("Event1")); Assert.That(con.Modifiers.Count, Is.EqualTo(1)); Assert.That(con.Modifiers[0], Is.EqualTo("public")); Assert.That(con.DataType.Name, Is.EqualTo("Delegate1")); }
public static ParseResults ParseCSharpFiles(IEnumerable<string> csharpFiles) { var parser = new CSharpParser(); var parseResults = new ParseResults(); foreach (var file in csharpFiles) { if (File.Exists(file) == false) continue; parser.Reset(); parser.ParseCode(file, File.ReadAllText(file)); parseResults.AddParsedFile(file, parser.CreatedCodeRoot as CodeRoot); } return parseResults; }
private void TestFiles() { foreach(string file in _Files) { try { GC.Collect(); CSharpParser parser = new CSharpParser(); parser.ParseCode(file, File.ReadAllText(file)); if (parser.ErrorOccurred == false) continue; Assert.IsNull(parser.ExceptionThrown, parser.ExceptionThrown == null ? "" : parser.ExceptionThrown.ToString()); Assert.That(parser.SyntaxErrors.Count, Is.EqualTo(0), "There were syntax errors in file " + file); } catch(Exception e) { Assert.Fail(e.ToString()); } } }
public void Parser_Exception_Thrown() { CSharpParser parser = new CSharpParser(); try { const string code = "Nonsense, and more nonsense."; parser.ParseSingleConstruct(code, BaseConstructType.ConstructorDeclaration); Assert.Fail("Parser exception not thrown"); } catch(ParserException) { // Everything went according to plan } Assert.That(parser.ErrorOccurred); Assert.That(parser.SyntaxErrors.Count, Is.GreaterThan(0)); }
public void TestFile(string filename, bool stripText, CSharpFormatSettings settings) { string fileText = File.ReadAllText(filename); CSharpParser formatter = new CSharpParser(); formatter.FormatSettings.SetFrom(settings); formatter.ParseCode(fileText); Assert.IsFalse(formatter.ErrorOccurred); string formattedText = formatter.CreatedCodeRoot.ToString(); formattedText = Slyce.Common.Utility.StandardizeLineBreaks(formattedText, Slyce.Common.Utility.LineBreaks.Windows); string strippedFileText = Diff.StripWhitespace(new[] {fileText}, stripText)[0].Replace("\t", " "); string strippedFormattedText = Diff.StripWhitespace(new[] { formattedText }, stripText)[0].Replace("\t", " "); Assert.That(strippedFormattedText, Is.EqualTo(strippedFileText)); }
public void They_Are_Added_Correctly() { var parser = new CSharpParser(); parser.ParseCode(Code.Class1Text); var codeRoot = (CodeRoot)parser.CreatedCodeRoot; var basicClass = codeRoot.Namespaces[0].Classes[0]; var property2 = new Property(codeRoot.Controller, "Property1", new DataType(codeRoot.Controller, "string"), "public"); var property3 = new Property(codeRoot.Controller, "Property2", new DataType(codeRoot.Controller, "Class1"), "private"); var action1 = new AddPropertyToClassAction(property2, AdditionPoint.EndOfParent, basicClass); var action2 = new AddPropertyToClassAction(property3, AdditionPoint.EndOfParent, basicClass); Actions actions = new Actions(); actions.AddAction(action1); actions.AddAction(action2); string output = actions.RunActions(parser); output = Slyce.Common.Utility.StandardizeLineBreaks(output, Environment.NewLine); Assert.That(output, Is.EqualTo(Code.Class1Plus2PropertiesText)); }
internal static ICodeRoot GetCodeRoot(string fileName) { CSharpParser formatter = new CSharpParser(); formatter.ParseCode(File.ReadAllText(fileName)); return formatter.CreatedCodeRoot; }
internal static void AssertFilesAreSame(string original, string changed) { CodeRootMap codeRootMap = new CodeRootMap(); CSharpParser formatter = new CSharpParser(); formatter.FormatSettings.ReorderBaseConstructs = true; formatter.ParseCode(File.ReadAllText(original)); ICodeRoot codeRoot = formatter.CreatedCodeRoot; codeRootMap.AddCodeRoot(codeRoot, Version.NewGen); codeRootMap.AddCodeRoot(codeRoot, Version.PrevGen); formatter = new CSharpParser(); formatter.FormatSettings.ReorderBaseConstructs = true; formatter.ParseCode(File.ReadAllText(changed)); codeRoot = formatter.CreatedCodeRoot; codeRootMap.AddCodeRoot(codeRoot, Version.User); Assert.That(codeRootMap.Diff(), Is.EqualTo(TypeOfDiff.ExactCopy)); }
public static FunctionInfo CreateFunctionInfoFrom(ApiExtensionMethod extMethod) { MethodInfo method = extMethod.ExtendedMethod; string formattedCode = extMethod.OverridingFunctionBody; if (extMethod.HasOverride == false && string.IsNullOrEmpty(extMethod.DefaultCode) == false) { CSharpParser parser = new CSharpParser(); parser.FormatSettings.MaintainWhitespace = false; string methodText = string.Format("public void {0} () {{ {1} }}", method.Name, extMethod.DefaultCode); var bc = parser.ParseSingleConstruct(methodText, BaseConstructType.MethodDeclaration); // Remove the start and end braces formattedCode = Utility.StandardizeLineBreaks(bc.ToString(), "\n"); // + 1 to get past the {, +1 to remove the first line break. formattedCode = formattedCode.Substring(formattedCode.IndexOf('{')+2); formattedCode = formattedCode.Substring(0, formattedCode.LastIndexOf('}')-1); formattedCode = RemoveTabs(formattedCode); } FunctionInfo fi = new FunctionInfo( method.Name, method.ReturnType, formattedCode, true, SyntaxEditorHelper.ScriptLanguageTypes.CSharp, extMethod.Description, "C#", "Extension Methods"); return fi; }
public void A_Structure_Is_Created() { const string code = "public struct Structure1 { }"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.StructureDeclaration); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(Struct))); Struct con = (Struct)bc; Assert.That(con.Name, Is.EqualTo("Structure1")); }
public void A_Destructor_Is_Created() { // This should not be the name of the class const string code = "public ~MadeUpClassName() { }"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.DestructorDeclaration); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(Destructor))); Destructor con = (Destructor)bc; Assert.That(con.Name, Is.EqualTo("MadeUpClassName")); Assert.That(con.BodyText, Is.EqualTo("{\n}\n".Replace("\n", Environment.NewLine))); }
public void An_InterfaceMethod_Is_Created() { const string code = "void Method1();"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.InterfaceMethodDeclaration); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(InterfaceMethod))); InterfaceMethod con = (InterfaceMethod)bc; Assert.That(con.Name, Is.EqualTo("Method1")); Assert.That(con.ReturnType.Name, Is.EqualTo("void")); }
public void A_Field_Is_Created() { const string code = "public string Key = \"12345\";"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.FieldDeclaration); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(Field))); Field con = (Field)bc; Assert.That(con.Name, Is.EqualTo("Key")); Assert.That(con.Modifiers.Count, Is.EqualTo(1)); Assert.That(con.Modifiers[0], Is.EqualTo("public")); Assert.That(con.DataType.Name, Is.EqualTo("string")); Assert.That(con.InitialValue, Is.EqualTo("\"12345\"")); }
public void A_Method_Is_Created() { const string code = "public static SomeDataType Method1(int i) { }"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.MethodDeclaration); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(Function))); Function con = (Function)bc; Assert.That(con.Name, Is.EqualTo("Method1")); Assert.That(con.Modifiers.Count, Is.EqualTo(2)); Assert.That(con.Modifiers[0], Is.EqualTo("public")); Assert.That(con.Modifiers[1], Is.EqualTo("static")); Assert.That(con.ReturnType.Name, Is.EqualTo("SomeDataType")); Assert.That(con.Parameters.Count, Is.EqualTo(1)); Assert.That(con.Parameters[0].DataType, Is.EqualTo("int")); Assert.That(con.Parameters[0].Name, Is.EqualTo("i")); }
public void A_Namespace_Is_Created() { const string code = "namespace Namespace1 { }"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.NamespaceDeclaration); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(Namespace))); Namespace con = (Namespace)bc; Assert.That(con.Name, Is.EqualTo("Namespace1")); }
public void A_UsingStatement_Is_Created() { const string code = "using System;"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.UsingDirective); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(UsingStatement))); UsingStatement con = (UsingStatement)bc; Assert.That(con.Value, Is.EqualTo("System")); }
public string GetFormattedDefaultCode() { bool isMethod = false; MethodInfo method = null; bool hasApiExt = false; string defaultCode = ""; foreach (MethodInfo meth in ObjectType.GetMethods()) { if (meth.Name == PropertyName) { ParameterInfo[] realParams = meth.GetParameters(); if (realParams.Length == ParameterTypes.Count) { bool paramsMatch = true; for (int paramCounter = 0; paramCounter < realParams.Length; paramCounter++) { if (realParams[paramCounter].ParameterType.FullName != ParameterTypes[paramCounter].DataType.FullName) { paramsMatch = false; break; } } if (paramsMatch) { object[] allAttributes = meth.GetCustomAttributes(false); foreach (object att in allAttributes) { Type attType = att.GetType(); if (Utility.StringsAreEqual(attType.Name, "ApiExtensionAttribute", true)) { hasApiExt = true; method = meth; defaultCode = (string)attType.InvokeMember("DefaultCode", BindingFlags.GetProperty, null, att, null); } } break; } } } } Type returnType = null; if (method != null) { isMethod = true; returnType = method.ReturnType; } else { PropertyInfo property = ObjectType.GetProperty(PropertyName); object[] allAttributes = property.GetCustomAttributes(false); foreach (object att in allAttributes) { Type attType = att.GetType(); if (Utility.StringsAreEqual(attType.Name, "ApiExtensionAttribute", true)) { hasApiExt = true; defaultCode = (string)attType.InvokeMember("DefaultCode", BindingFlags.GetProperty, null, att, null); break; } } returnType = property.PropertyType; } if (!hasApiExt)// attributes != null && attributes.Length == 0) { throw new NotImplementedException(String.Format("DefaultCodeAttribute not implemented for {0}.{1} yet.", ObjectType.FullName, PropertyName)); } string code = defaultCode;// attributes[0].DefaultCode; CSharpParser csf = new CSharpParser(); if (isMethod) { Function f = (Function)csf.ParseSingleConstruct("public void Method1(){ " + code + " }", BaseConstructType.MethodDeclaration); code = f.BodyText; } else { Property p = (Property)csf.ParseSingleConstruct("public int Property1 { " + code + " }", BaseConstructType.PropertyDeclaration); if (p.GetAccessor != null) code = p.GetAccessor.BodyText; else code = p.SetAccessor.BodyText; } int secondLineBreak = code.IndexOf("\r\n", code.IndexOf("{")) + 2; int lastLineBreak = code.LastIndexOf("\r\n", code.LastIndexOf("}")); if (lastLineBreak > secondLineBreak) { code = code.Substring(secondLineBreak, lastLineBreak - secondLineBreak); } else { code = ""; } string[] lines = Utility.StandardizeLineBreaks(code, Utility.LineBreaks.Unix).Split('\n'); StringBuilder sb = new StringBuilder(lines.Length * 100); for (int i = 0; i < lines.Length; i++) { if (lines[i].Length > 1) { sb.AppendLine(lines[i].Substring(1)); } else { sb.AppendLine(lines[i]); } } return sb.ToString(); }
public void A_Delegate_Is_Created() { const string code = "public delegate int Delegate1();"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.DelegateDeclaration); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(Delegate))); Delegate con = (Delegate)bc; Assert.That(con.Name, Is.EqualTo("Delegate1")); Assert.That(con.Parameters.Count, Is.EqualTo(0)); Assert.That(con.ReturnType.Name, Is.EqualTo("int")); Assert.That(con.Modifiers.Count, Is.EqualTo(1)); Assert.That(con.Modifiers[0], Is.EqualTo("public")); }
private void CallFunction() { try { SetUserOptionValues(); string fileName = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "temp.aal"); string str = (string)Loader.Instance.CallTemplateFunction(TheFunction.Name, ref ParametersToPass); if (TheFunction.IsTemplateFunction) { //SetSyntaxLanguage(Slyce.Common.SyntaxEditorHelper.LanguageEnumFromName(TheFunction.ReturnType.Name)); } else { //SetSyntaxLanguage(Project.OutputLanguageTypes.PlainText); } syntaxEditor1.Text = str; if (Project.Instance.TextLanguage == TemplateContentLanguage.CSharp) { CSharpParser formatter = new CSharpParser(); formatter.ParseCode(str); if(formatter.ErrorOccurred) { StringBuilder errorMsg = new StringBuilder(); foreach(ParserSyntaxError error in formatter.SyntaxErrors) { errorMsg.AppendFormat("An error occurred on line {1}:\n\n{0}", error.ErrorMessage, error.LineNumber); errorMsg.AppendLine(); } MessageBox.Show(this, errorMsg.ToString(), "Formatting Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } else { str = formatter.CreatedCodeRoot.ToString(); syntaxEditorFormatted.Text = Utility.StandardizeLineBreaks(str, Utility.LineBreaks.Windows); } } } catch (Exception ex) { Controller.ReportError(ex); } }
public void A_Property_Is_Created() { const string code = "public int Property1 { get {return 1; } }"; CSharpParser parser = new CSharpParser(); IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.PropertyDeclaration); Assert.That(bc, Is.Not.Null); Assert.That(bc, Is.InstanceOfType(typeof(Property))); Property con = (Property)bc; Assert.That(con.Name, Is.EqualTo("Property1")); Assert.That(con.Modifiers.Count, Is.EqualTo(1)); Assert.That(con.Modifiers[0], Is.EqualTo("public")); Assert.That(con.DataType.Name, Is.EqualTo("int")); Assert.That(con.GetAccessor, Is.Not.Null); Assert.That(con.SetAccessor, Is.Null); Assert.That(con.GetAccessor.BodyText, Is.EqualTo("{ return 1; }")); }