public void CSharpHelperConvertsCSharpTextsToApexDictionary() { var csharp = @" class Test1 { public Test1(int x) { } } class Test2 : Test1 { private int x = 10; } enum SomeEnum { None, Unknown, Default }"; var apexClasses = ApexSharpParser.ConvertToApex(csharp); Assert.AreEqual(3, apexClasses.Count); CompareLineByLine( @"class Test1 { public Test1(Integer x) { } }", apexClasses["Test1"]); CompareLineByLine( @"class Test2 extends Test1 { private Integer x = 10; }", apexClasses["Test2"]); CompareLineByLine( @"enum SomeEnum { None, Unknown, Default }", apexClasses["SomeEnum"]); }
public void CSharpHelperParsesTheCSharpCodeAndReturnsTheSyntaxTree() { var unit = ApexSharpParser.ParseText( @"using System; using System.Collections; using System.Linq.Think; using System.Text; using system.debug; namespace HelloWorld { class Program { static void Main(string[] args) { Console.WriteLine(""Hello, World!""); } } }"); Assert.NotNull(unit); var txt = ApexSharpParser.ToCSharp(unit); Assert.NotNull(txt); }
public void SampleWalkerDisplaysTheSyntaxTreeStructure() { var unit = ApexSharpParser.ParseText( @"using System; using System.Collections; using System.Linq.Think; using System.Text; using system.debug; namespace Demo { struct Program { static void Main(string[] args) { Console.WriteLine(""Hello, World!""); } } }"); var walker = new SampleWalker(); unit.Accept(walker); var tree = walker.ToString(); Assert.False(string.IsNullOrWhiteSpace(tree)); }
public void ClassUnitTestRoundtrip() { // formatted class doesn't match the converted class because of the testMethod modifiers CompareLineByLine(ApexSharpParser.IndentApex(ClassUnitTest_Original), ClassUnitTest_Formatted); CompareLineByLine(ApexToCSharpHelpers.ConvertToCSharp(ClassUnitTest_Original, Options), ClassUnitTest_CSharp1); CompareLineByLine(CSharpToApexHelpers.ConvertToApex(ClassUnitTest_CSharp1)[0], ClassUnitTest_Converted); }
public static void ConvertToApex(FileInfo cSharpFile, DirectoryInfo apexLocation, int version) { if (!apexLocation.Exists) { throw new DirectoryNotFoundException(apexLocation.FullName); } if (!cSharpFile.Exists) { throw new FileNotFoundException(cSharpFile.FullName); } // Convert C# to Apex var csharpCode = File.ReadAllText(cSharpFile.FullName); foreach (var convertedClass in ApexSharpParser.ConvertToApex(csharpCode)) { var apexFileName = Path.ChangeExtension(convertedClass.Key, ".cls"); var apexFile = Path.Combine(apexLocation.FullName, apexFileName); File.WriteAllText(apexFile, convertedClass.Value); var metaFileName = Path.ChangeExtension(apexFile, ".cls-meta.xml"); var metaFile = new StringBuilder(); metaFile.AppendLine("<?xml version = \"1.0\" encoding = \"UTF-8\"?>"); metaFile.AppendLine("<ApexClass xmlns = \"http://soap.sforce.com/2006/04/metadata\">"); metaFile.AppendLine($"<apiVersion>{version}.0</apiVersion>"); metaFile.AppendLine("<status>Active</status>"); metaFile.AppendLine("</ApexClass>"); File.WriteAllText(metaFileName, metaFile.ToString()); Console.WriteLine(metaFileName); } }
public static bool IsRelated(string apexText, string apexClassName) { if (string.IsNullOrWhiteSpace(apexText) || string.IsNullOrWhiteSpace(apexClassName)) { return(false); } try { // try to parse and analyze the file var ast = ApexSharpParser.GetApexAst(apexText); // ignore the class itself if (ast is ClassDeclarationSyntax @class && Comparer.Equals(@class.Identifier, apexClassName)) { return(false); } else if (ast is EnumDeclarationSyntax @enum && Comparer.Equals(@enum.Identifier, apexClassName)) { return(false); } // inspect the code structure var visitor = new RelatedClassHelper(apexClassName); ast.Accept(visitor); return(visitor.ClassIsRelated); }
private ClassDeclarationSyntax ParseClass(string apexClass) { var result = ApexSharpParser.GetApexAst(apexClass) as ClassDeclarationSyntax; Assert.NotNull(result); return(result); }
public static List <FileFormatDto> FormatApexCode(DirectoryInfo apexFolderName) { List <FileFormatDto> dtoList = new List <FileFormatDto>(); var files = Directory.GetFiles(apexFolderName.FullName, "*.cls", SearchOption.TopDirectoryOnly); foreach (var sourceFile in files) { FileInfo apexFileInfo = new FileInfo(sourceFile); Console.WriteLine($"Formatting file: {sourceFile}..."); var backupFile = sourceFile + ".bak"; File.Delete(backupFile); File.Move(sourceFile, backupFile); var apexCode = File.ReadAllText(backupFile); var formatted = ApexSharpParser.IndentApex(apexCode); File.WriteAllText(sourceFile, formatted); File.Delete(backupFile); FileFormatDto dto = new FileFormatDto { ApexFileName = apexFileInfo.FullName, ApexFileBeforeFormat = apexCode, ApexFileAfterFormat = formatted }; dtoList.Add(dto); } Console.WriteLine($"Done. Formatted {dtoList.Count} files."); return(dtoList); }
private void Check(string apexOriginal, string apexFormatted, string csharp) { Assert.Multiple(() => { CompareLineByLine(ApexSharpParser.IndentApex(apexOriginal), apexFormatted); CompareLineByLine(ApexToCSharpHelpers.ConvertToCSharp(apexOriginal, Options), csharp); CompareLineByLine(CSharpToApexHelpers.ConvertToApex(csharp)[0], apexFormatted); }); }
protected void Check(BaseSyntax node, string expected) { string nows(string s) => NoWhitespaceRegex.Replace(s, string.Empty); var nodeToApex = node.ToApex(); Assert.AreEqual(nows(expected), nows(nodeToApex)); CompareLineByLine(nodeToApex, ApexSharpParser.IndentApex(expected)); }
public static string FormatApex(string apexCode, Settings settings = null) { if (string.IsNullOrWhiteSpace(apexCode)) { return(string.Empty); } var apexAst = ApexSharpParser.GetApexAst(apexCode); return(GenerateApex(apexAst, settings)); }
private string ToCSharp(string s) { try { return(ApexSharpParser.ConvertApexToCSharp(s)); } catch (ParseException) { return(string.Empty); } }
public Dictionary <string, ClassReference> ProcessApexClasses(params string[] apexTexts) { if (apexTexts == null || !apexTexts.Any(t => !string.IsNullOrWhiteSpace(t))) { return(ProcessCSharpClasses()); } var csharpClasses = apexTexts.Select(c => ApexSharpParser.ConvertApexToCSharp(c)).ToArray(); return(ProcessCSharpClasses(csharpClasses)); }
public CodeFormatTest() { DirectoryInfo directoryInfo = new DirectoryInfo(@"C:\Dev\codeformat\src\classes\"); //DirectoryInfo directoryInfo = new DirectoryInfo(@"C:\DevSharp\ApexSharpFsb\FSB\ApexClasses\"); List <FileFormatDto> results = ApexCodeFormater.FormatApexCode(directoryInfo); foreach (var result in results) { Console.WriteLine(result.ApexFileName); var apexAst = ApexSharpParser.GetApexAst(result.ApexFileAfterFormat); } }
public void SoqlStatementFormattingDoesntMessUpParameters() { var apex = @"class SoqlDemo { void soql() { list<r> rr = [select c, min(b) d from r WHERE c in :triggerNew AND b not in :triggerNew GROUP BY c HAVING count(b) > 1]; } }"; var formatted = ApexSharpParser.IndentApex(apex); Assert.IsFalse(formatted.Contains("trigger new")); Assert.IsFalse(formatted.Contains("GROUPBY")); }
protected void Check(string csharpUnit, params string[] apexClasses) { var csharpNode = ApexSharpParser.ParseText(csharpUnit); var apexNodes = ApexSyntaxBuilder.GetApexSyntaxNodes(csharpNode); Assert.Multiple(() => { Assert.AreEqual(apexClasses.Length, apexNodes.Count); foreach (var apexItem in apexNodes.Zip(apexClasses, (node, text) => new { node, text })) { Check(apexItem.node, apexItem.text); } }); }
public static void ConvertToApex(DirectoryInfo cSharpLocation, DirectoryInfo apexLocation, int version) { if (!apexLocation.Exists) { throw new DirectoryNotFoundException(apexLocation.FullName); } if (!cSharpLocation.Exists) { throw new DirectoryNotFoundException(cSharpLocation.FullName); } // Convert C# to Apex ApexSharpParser.ConvertToApex(cSharpLocation.FullName, apexLocation.FullName, version); }
public static void ConvertToCSharp(DirectoryInfo apexLocation, DirectoryInfo cSharpLocation, string nameSpace) { if (!apexLocation.Exists) { throw new DirectoryNotFoundException(apexLocation.FullName); } if (!cSharpLocation.Exists) { throw new DirectoryNotFoundException(cSharpLocation.FullName); } // Convert APEX to C# ApexSharpParser.ConvertToCSharp(apexLocation.FullName, cSharpLocation.FullName, nameSpace); }
public static void ConvertToApex() { // Location of your APEX and C# Files that we will be converting DirectoryInfo apexLocation = new DirectoryInfo(@"\ApexSharp\SalesForce\src\classes\"); DirectoryInfo cSharpLocation = new DirectoryInfo(@"\ApexSharp\Demo\CSharpClasses\"); //// Convert to C# to Apex if (apexLocation.Exists && cSharpLocation.Exists) { ApexSharpParser.ConvertToApex(cSharpLocation.FullName, apexLocation.FullName, 40); } else { Console.WriteLine("Missing Directory"); } }
public void EmptyClassIsGenerated() { var csharp = "class Test {}"; var cs = ApexSharpParser.ParseText(csharp); var apex = ApexSyntaxBuilder.GetApexSyntaxNodes(cs); Assert.NotNull(apex); Assert.AreEqual(1, apex.Count); var cd = apex.OfType <ClassDeclarationSyntax>().FirstOrDefault(); Assert.NotNull(cd); Assert.AreEqual("Test", cd.Identifier); Check(csharp, "class Test {}"); }
public void CSharpHelperConvertsCSharpTextsToApex() { var csharp = "class Test1 { public Test1(int x) { } } class Test2 : Test1 { private int x = 10; }"; var apexClasses = ApexSharpParser.ToApex(csharp); Assert.AreEqual(2, apexClasses.Length); CompareLineByLine( @"class Test1 { public Test1(Integer x) { } }", apexClasses[0]); CompareLineByLine( @"class Test2 extends Test1 { private Integer x = 10; }", apexClasses[1]); }
public static void ConvertToCSharp(FileInfo apexFile, DirectoryInfo cSharpLocation, string nameSpace) { if (!apexFile.Exists) { throw new FileNotFoundException(apexFile.FullName); } if (!cSharpLocation.Exists) { throw new DirectoryNotFoundException(cSharpLocation.FullName); } // Convert APEX to C# var apexClass = File.ReadAllText(apexFile.FullName); var csharpClass = ApexSharpParser.ConvertApexToCSharp(apexClass, nameSpace); // Write the converted file to the target directory var csharpClassName = Path.ChangeExtension(apexFile.Name, "cs"); var csharpFullName = Path.Combine(cSharpLocation.FullName, csharpClassName); File.WriteAllText(csharpFullName, csharpClass); }
public void TestCodeGeneration() { var apex = @" class Something { @IsTest public static void testPluckDecimals() { List<Account> accounts = testData(); LIST<decimal> revenues = Pluck.decimals(accounts, Account.AnnualRevenue); System.deBUG(4, revenues.size()); System.assertNOTequals(100.0, revenues[0]); // SYSTEM system.assertEquals(60.0, revenues[1]); // 'deBUG' SYSTEM.assertEquals(150.0, revenues[2]); System.Debug(150.0, revenues[3]); } }"; var parsed = ApexSharpParser.GetApexAst(apex); var generated = ApexCleanCodeGen.GenerateApex(parsed); Assert.NotNull(generated); Assert.AreEqual(@"class Something { @IsTest public static void testPluckDecimals() { List<Account> accounts = testData(); List<Decimal> revenues = Pluck.decimals(accounts, Account.AnnualRevenue); System.debug(4, revenues.size()); System.assertNotEquals(100.0, revenues[0]); // SYSTEM System.assertEquals(60.0, revenues[1]); // 'deBUG' System.assertEquals(150.0, revenues[2]); System.debug(150.0, revenues[3]); } } ", generated); }
public void DetectTestClassExample1() { var ast = ApexSharpParser.GetApexAst("class Example1 {}"); Assert.IsFalse(IsTestClass(ast)); }
private void Check(string source, string expected) => CompareLineByLine(ApexSharpParser.IndentApex(source), expected);
public static string NormalizeCode(string apexCode) { var apexAst = ApexSharpParser.GetApexAst(apexCode); return(GenerateApex(apexAst)); }
// Convert Apex Code to C# public static string ConvertToCSharp(string apexCode, string @namespace = null) { return(ApexSharpParser.GetApexAst(apexCode).ToCSharp(@namespace: @namespace)); }
public void DetectTestClassExample3() { var ast = ApexSharpParser.GetApexAst("@isTest enum Example2 { A, B, C }"); Assert.IsFalse(IsTestClass(ast)); }
// Convert Apex Code to C# with custom options public static string ConvertToCSharp(string apexCode, ApexSharpParserOptions options) { return(ApexSharpParser.GetApexAst(apexCode).ToCSharp(options)); }
public void DetectTestClassExample2() { var ast = ApexSharpParser.GetApexAst("@isTest class Example2 {}"); Assert.IsTrue(IsTestClass(ast)); }