public void TestAddingAssemblyReferences_PropertyInitializer()
{
// Arrange
string fileName = "TestFile";
string fileExtension = "cs";
string fullFileName = $"{fileName}.{fileExtension}";
string assemblyName = "System";
string assemblyName2 = "System.Text";
SGAssemblyReference assemblyReference = new SGAssemblyReference(assemblyName);
SGAssemblyReference assemblyReference2 = new SGAssemblyReference(assemblyName2);
// Act
SGFile file = new SGFile(fullFileName)
{
AssemblyReferences =
{
assemblyReference,
assemblyReference2
}
};
// Assert
Assert.IsTrue(file.AssemblyReferences.ContainsAll(new List <SGAssemblyReference>
{
assemblyReference,
assemblyReference2
}));
}
public void TestAddingNamespaces_PropertyInitializer()
{
// Arrange
string fileName = "TestFile";
string fileExtension = "cs";
string fullFileName = $"{fileName}.{fileExtension}";
string namespaceName = "SlnGen.Core";
string namespaceName2 = "SlnGen.Core.Code";
SGNamespace namespace1 = new SGNamespace(namespaceName);
SGNamespace namespace2 = new SGNamespace(namespaceName2);
// Act
SGFile file = new SGFile(fullFileName)
{
Namespaces =
{
namespace1,
namespace2
}
};
// Assert
Assert.IsTrue(file.Namespaces.ContainsAll(new List <SGNamespace>
{
namespace1,
namespace2
}));
}
public void TestEmptyName_ThrowsArgumentException()
{
// Arrange
string fullFileName = String.Empty;
// Act
SGFile file = new SGFile(fullFileName);
}
public void TestNullName_ThrowsArgumentNullException()
{
// Arrange
string fullFileName = null;
// Act
SGFile file = new SGFile(fullFileName);
}
public void TestFileNameEndsInPeriod_ThrowsException()
{
// Arrange
string fileName = "TestFile.";
string fileExtension = "cs";
// Act
SGFile file = new SGFile(fileName, fileExtension);
}
public void TestEmptyFileExtension_ThrowsArgumentException()
{
// Arrange
string fileName = "TestFile";
string fileExtension = String.Empty;
// Act
SGFile file = new SGFile(fileName, fileExtension);
}
public void TestFileExtensionContainsPeriods_ThrowsArgumentException()
{
// Arrange
string fileName = "TestFile";
string fileExtension = ".cs";
// Act
SGFile file = new SGFile(fileName, fileExtension);
}
public void TestNullFileName_ThrowsArgumentNullException()
{
// Arrange
string fileName = null;
string fileExtension = "cs";
// Act
SGFile file = new SGFile(fileName, fileExtension);
}
public void TestFileNameStartsWithPeriod_ThrowsException()
{
// Arrange
string fileName = ".TestFile";
string fileExtension = "cs";
// Act
SGFile file = new SGFile(fileName, fileExtension);
}
public void TestNameWithNoPeriod_ThrowsArgumentException()
{
// Arrange
string fileName = "TestFile";
string fileExtension = "cs";
string fullFileName = $"{fileName}{fileExtension}";
// Act
SGFile file = new SGFile(fullFileName);
}
public MainActivityFile(string appName, string assemblyName) : base("MainActivity.cs")
{
SGFile file = new SGFile("MainActivity.cs")
{
UsingStatements =
{
new CGUsingStatement("System"),
new CGUsingStatement("Android.App"),
new CGUsingStatement("Android.Content.PM"),
new CGUsingStatement("Android.Runtime"),
new CGUsingStatement("Android.Views"),
new CGUsingStatement("Android.Widget"),
new CGUsingStatement("Android.OS")
},
Namespaces =
{
new CGNamespace(assemblyName)
{
Classes =
{
new CGClass("MainActivity", "global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity")
{
ClassAttributes =
{
$"[Activity(Label = \"{appName}\", Icon = \"@drawable/icon\", Theme = \"@style/MainTheme\", MainLauncher = true, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]"
},
ClassMethods =
{
new CGMethod(new CGMethodSignature(AccessibilityLevel.Protected, "OnCreate", "void", false, true)
{
Arguments =
{
new CGMethodArgument("Bundle", "bundle")
}
})
{
MethodText = String.Concat(
"TabLayoutResource = Resource.Layout.Tabbar;", Environment.NewLine,
"ToolbarResource = Resource.Layout.Toolbar;", Environment.NewLine,
Environment.NewLine,
"base.OnCreate(bundle);", Environment.NewLine,
Environment.NewLine,
"global::Xamarin.Forms.Forms.Init(this, bundle);", Environment.NewLine,
"LoadApplication(new App());"
)
}
}
}
}
}
}
};
this.FileContents = file.ToString();
}
public AppDelegateFile(string rootNamespace) : base(s_fileName, true, false)
{
FileContents = new SGFile(s_fileName)
{
AssemblyReferences =
{
new SGAssemblyReference("System"),
new SGAssemblyReference("System.Collections.Generic"),
new SGAssemblyReference("System.Linq"),
new SGAssemblyReference("Foundation"),
new SGAssemblyReference("UIKit")
},
Namespaces =
{
new SGNamespace(rootNamespace)
{
Classes =
{
new SGClass("AppDelegate", SGAccessibilityLevel.Public, false, false, true)
{
BaseClass = "global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate",
//Comments =
Attributes =
{
new SGAttribute("Register", "\"AppDelegate\"")
},
Methods =
{
new SGMethod(new SGMethodSignature("FinishedLaunching", SGAccessibilityLevel.Public, false, false, true, "bool")
{
Arguments =
{
new SGArgument("UIApplication", "app"),
new SGArgument("NSDictionary", "options")
}
})
{
//Comments =
Lines =
{
"global::Xamarin.Forms.Forms.Init();",
"LoadApplication(new App());",
"",
"return base.FinishedLaunching(app, options);"
}
}
}
}
}
}
}
}.ToString();
}
public void TestFileNameContainsMultiplePeriods_InitsFields()
{
// Arrange
string fileName = "TestFile.Test.MoreTests";
string fileExtension = "cs";
// Act
SGFile file = new SGFile(fileName, fileExtension);
// Assert
Assert.AreEqual(fileName, file.FileName);
Assert.AreEqual(fileExtension, file.FileExtension);
}
public void TestFileNameAndExtensionCtor_InitsFields()
{
// Arrange
string fileName = "TestFile";
string fileExtension = "cs";
// Act
SGFile file = new SGFile(fileName, fileExtension);
// Assert
Assert.AreEqual(fileName, file.FileName);
Assert.AreEqual(fileExtension, file.FileExtension);
}
public void TestStingleStringCtor_InitsFields()
{
// Arrange
string fileName = "TestFile";
string fileExtension = "cs";
string fullFileName = $"{fileName}.{fileExtension}";
// Act
SGFile file = new SGFile(fullFileName);
// Assert
Assert.AreEqual(fileName, file.FileName);
Assert.AreEqual(fileExtension, file.FileExtension);
}
public void TestSingleStringContainsMultiplePeriods_InitsFields()
{
// Arrange
string fileName = "TestFile.MoreTests.Test";
string fileExtension = "cs";
string fullFileName = $"{fileName}.{fileExtension}";
// Act
SGFile file = new SGFile(fullFileName);
// Assert
Assert.AreEqual(fileName, file.FileName);
Assert.AreEqual(fileExtension, file.FileExtension);
}
public void TestAddingAssemblyReference_FluentAPI()
{
// Arrange
string fileName = "TestFile";
string fileExtension = "cs";
string fullFileName = $"{fileName}.{fileExtension}";
string assemblyName = "System";
SGAssemblyReference assemblyReference = new SGAssemblyReference(assemblyName);
// Act
SGFile file = new SGFile(fullFileName).WithAssemblies(assemblyReference);
// Assert
Assert.IsTrue(file.AssemblyReferences.Contains(assemblyReference));
}
public void TestAddingNamespace_FluentAPI()
{
// Arrange
string fileName = "TestFile";
string fileExtension = "cs";
string fullFileName = $"{fileName}.{fileExtension}";
string namespaceName = "SlnGen.Core";
SGNamespace @namespace = new SGNamespace(namespaceName);
// Act
SGFile file = new SGFile(fullFileName).WithNamespaces(@namespace);
// Assert
Assert.IsTrue(file.Namespaces.Contains(@namespace));
}
public MainActivityFile(string appName, string rootNamespace) : base("MainActivity.cs")
{
SGFile file = new SGFile("MainActivity.cs")
{
AssemblyReferences =
{
new SGAssemblyReference("System"),
new SGAssemblyReference("Android.App"),
new SGAssemblyReference("Android.Content.PM"),
new SGAssemblyReference("Android.Runtime"),
new SGAssemblyReference("Android.Views"),
new SGAssemblyReference("Android.Widget"),
new SGAssemblyReference("Android.OS")
},
Namespaces =
{
new SGNamespace(rootNamespace)
{
Classes =
{
new SGClass("MainActivity", SGAccessibilityLevel.Public)
{
Attributes =
{
new SGAttribute("Activity", $"Label = \"{appName}\"", "Icon = \"@mipmap/icon\"", "Theme = \"@style/MainTheme\"",
"MainLauncher = true", "ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation")
},
Methods =
{
new SGMethod(new SGMethodSignature("OnCreate", SGAccessibilityLevel.Protected, false, false, true, "void"))
{
Lines =
{
"TabLayoutResource = Resource.Layout.Tabbar;",
"ToolbarResrouce = Resource.Layout.Toolbar;",
"",
"base.OnCreate(savedInstanceState);",
"global::Xamarin.Forms.Forms.Init(this, savedInstanceState);",
"LoadApplication(new App());"
}
}
}
}
}
}
}
};
}
public IOSMainFile(string assemblyName) : base("Main.cs", true, false)
{
SGFile file = new SGFile("Main.cs")
{
UsingStatements =
{
new CGUsingStatement("System"),
new CGUsingStatement("System.Collections.Generic"),
new CGUsingStatement("System.Linq"),
new CGUsingStatement("Foundation"),
new CGUsingStatement("UIKit")
},
Namespaces =
{
new CGNamespace(assemblyName)
{
Classes =
{
new CGClass("Application")
{
ClassMethods =
{
new CGMethod(new CGMethodSignature("Main", "void", true, false)
{
Arguments =
{
new CGMethodArgument("string[]", "args")
}
})
{
MethodComments =
{
"This is the main entry point of the application."
},
MethodText = String.Concat(
"// if you want to use a different Application Delegate class from \"AppDelegate\"", Environment.NewLine,
"// you can specify it here.", Environment.NewLine,
"UIApplication.Main(args, null, \"AppDelegate\");"
)
}
}
}
}
}
}
};
}
public void TestAddingMultipleAssemblyReferences_FluentAPI()
{
// Arrange
string fileName = "TestFile";
string fileExtension = "cs";
string fullFileName = $"{fileName}.{fileExtension}";
string assemblyName = "System";
string assemblyName2 = "System.Text";
SGAssemblyReference assemblyReference = new SGAssemblyReference(assemblyName);
SGAssemblyReference assemblyReference2 = new SGAssemblyReference(assemblyName2);
// Act
SGFile file = new SGFile(fullFileName).WithAssemblies(assemblyReference, assemblyReference2);
// Assert
Assert.IsTrue(file.AssemblyReferences.ContainsAll(new List <SGAssemblyReference>
{
assemblyReference,
assemblyReference2
}));
}
public void TestAddingMultipleNamespaces_FluentAPI()
{
// Arrange
string fileName = "TestFile";
string fileExtension = "cs";
string fullFileName = $"{fileName}.{fileExtension}";
string namespaceName = "SlnGen.Core";
string namespaceName2 = "SlnGen.Core.Code";
SGNamespace namespace1 = new SGNamespace(namespaceName);
SGNamespace namespace2 = new SGNamespace(namespaceName2);
// Act
SGFile file = new SGFile(fullFileName).WithNamespaces(namespace1, namespace2);
// Assert
Assert.IsTrue(file.Namespaces.ContainsAll(new List <SGNamespace>
{
namespace1,
namespace2
}));
}
public iOSMainFile(string rootNamespace) : base(s_fileName, true, false)
{
FileContents = new SGFile(s_fileName)
{
AssemblyReferences =
{
new SGAssemblyReference("System"),
new SGAssemblyReference("System", "Collections", "Generic"),
new SGAssemblyReference("System.Linq"),
new SGAssemblyReference("Foundation"),
new SGAssemblyReference("UIKit")
},
Namespaces =
{
new SGNamespace(rootNamespace)
{
Classes =
{
new SGClass("Application", SGAccessibilityLevel.Public)
{
Methods =
{
new SGMethod(new SGMethodSignature("Main", SGAccessibilityLevel.None, true))
{
//Comments = { }
Lines =
{
"// if you want to use a different Application Delegate class from \"AppDelegate\"",
"// you can specify it here.",
"UIApplication.Main(args, null, \"AppDelegate\");"
}
}
}
}
}
}
}
}.ToString();
}
/// <summary>
/// Initializes a new instance of the <see cref="EmbeddedResourceProjectFile"/> class.
/// </summary>
/// <param name="file">The file.</param>
/// <param name="subType">The subtype.</param>
/// <param name="generator">The generator.</param>
public EmbeddedResourceProjectFile(SGFile file, string subType, string generator) : base(file)
{
SubType = subType;
Generator = generator;
}
/// <summary>
/// Initializes a new instance of the <see cref="FileTemplate"/> class.
/// </summary>
/// <param name="file">The file.</param>
public FileTemplate(SGFile file)
{
TemplateText = file.ToString();
}
public DefaultAppXamlFile(string namespaceName) : base("App")
{
XNamespace @namespace = "http://xamarin.com/schemas/2014/forms";
XNamespace xNamespace = "http://schemas.microsoft.com/winfx/2009/xaml";
XElement rootNode = new XElement(@namespace + "Application",
//new XAttribute("xmlns", "http://xamarin.com/schemas/2014/forms"),
//new XAttribute("xmlns", "http://schemas.microsoft.com/winfx/2009/xaml"),
new XAttribute(xNamespace + "Class", $"{namespaceName}.App"),
new XElement(@namespace + "Application.Resources"
)
);
using (var memoryStream = new MemoryStream())
{
rootNode.Save(memoryStream);
memoryStream.Position = 0;
using (var streamReader = new StreamReader(memoryStream))
{
XamlFileContents = streamReader.ReadToEnd();
}
}
SGFile file = new SGFile("App.xaml.cs")
{
AssemblyReferences =
{
new SGAssemblyReference("System"),
new SGAssemblyReference("Xamarin.Forms"),
new SGAssemblyReference("Xamarin.Forms.Xaml")
},
Namespaces =
{
new SGNamespace(namespaceName)
{
Attributes =
{
new SGAttribute("XamlCompilation", "XamlCompilationOptions.Compile").WithNamespace("assembly")
},
Classes =
{
new SGClass("App", SGAccessibilityLevel.Public, false, false, true)
{
Constructors =
{
new SGClassConstructor("App", SGAccessibilityLevel.Public)
{
Lines =
{
"InitializeComponent();",
"",
"MainPage = new MainPage();"
}
}
},
Methods =
{
new SGMethod(new SGMethodSignature("OnStart", SGAccessibilityLevel.Protected, isOverride: true, returnType: "void"))
{
Lines ={ "// Handle when your app starts" }
},
new SGMethod(new SGMethodSignature("OnSleep", SGAccessibilityLevel.Protected, isOverride: true, returnType: "void"))
{
Lines ={ "// Handle when your app sleeps" }
},
new SGMethod(new SGMethodSignature("OnResume", SGAccessibilityLevel.Protected, isOverride: true, returnType: "void"))
{
Lines ={ "// Handle when your app resumes" }
}
}
}.WithBaseClass("Application")
}
}
}
};
XamlCsFileContents = file.ToString();
}
public DefaultMainPageXamlFile(string assemblyName) : base("MainPage")
{
XNamespace @namespace = "http://xamarin.com/schemas/2014/forms";
XNamespace xNamespace = "http://schemas.microsoft.com/winfx/2009/xaml";
XNamespace localNamespace = $"clr-namespace:{assemblyName}";
XElement rootNode = new XElement(@namespace + "ContentPage",
//new XAttribute(@namespace+"xmlns", "http://xamarin.com/schemas/2014/forms"),
//new XAttribute(xNamespace+"xmlns", "http://schemas.microsoft.com/winfx/2009/xaml"),
//new XAttribute(localNamespace+"xmlns", $"clr-namespace:{assemblyName}"),
new XAttribute(xNamespace + "Class", $"{assemblyName}.MainPage"),
new XElement(@namespace + "Label",
new XAttribute("Text", "Welcome to Xamarin Forms!"),
new XAttribute("VerticalOptions", "Center"),
new XAttribute("HorizontalOptions", "Center")
)
);
using (var memoryStream = new MemoryStream())
{
rootNode.Save(memoryStream);
memoryStream.Position = 0;
using (var streamReader = new StreamReader(memoryStream))
{
XamlFileContents = streamReader.ReadToEnd();
}
}
SGFile file = new SGFile("MainPage.xaml.cs")
{
UsingStatements =
{
new CGUsingStatement("System"),
new CGUsingStatement("System.Collections.Generic"),
new CGUsingStatement("System.Linq"),
new CGUsingStatement("System.Text"),
new CGUsingStatement("System.Threading.Tasks"),
new CGUsingStatement("Xamarin.Forms")
},
Namespaces =
{
new CGNamespace(assemblyName)
{
Classes =
{
new CGClass("MainPage", "ContentPage", false, false, true)
{
ClassConstructors =
{
new CGClassConstructor("MainPage")
{
ConstructorText =
{
"InitializeComponent();"
}
}
}
}
}
}
}
};
XamlCsFileContents = file.ToString();
}
public AndroidResourceProjectFile(SGFile file) : base(file, false, false)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ProjectFile"/> class.
/// </summary>
/// <param name="file">The file.</param>
/// <param name="shouldCompile">if set to <c>true</c> [should compile].</param>
/// <param name="isContent">if set to <c>true</c> [is content].</param>
public ProjectFile(SGFile file, bool shouldCompile, bool isContent) :
this(String.Concat(file.FileName, ".", file.FileExtension), shouldCompile, isContent, file.ToString())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ProjectFile"/> class.
/// </summary>
/// <param name="file">The file.</param>
public ProjectFile(SGFile file) :
this(String.Concat(file.FileName, ".", file.FileExtension), true, false, file.ToString())
{
}
