/// <summary>
/// Parses a namespace definition.
/// </summary>
/// <returns>A namespace code element.</returns>
private NamespaceElement ParseNamespace()
{
NamespaceElement namespaceElement = new NamespaceElement();
string namepaceName = CaptureWord();
namespaceElement.Name = namepaceName;
//
// Parse child elements
//
List<ICodeElement> childElements = ParseElements(namespaceElement);
foreach (ICodeElement childElement in childElements)
{
namespaceElement.AddChild(childElement);
}
EatWhiteSpace();
EatWord(VBKeyword.Namespace, "Expected End Namespace");
return namespaceElement;
}
/// <summary>
/// Processes a namespace element.
/// </summary>
/// <param name="element">Namespace code element.</param>
public override void VisitNamespaceElement(NamespaceElement element)
{
this.WriteComments(element.HeaderComments);
StringBuilder builder = new StringBuilder(DefaultBlockLength);
builder.Append(VBKeyword.Namespace);
builder.Append(' ');
builder.Append(element.Name);
WriteIndented(builder.ToString());
WriteBeginBlock();
WriteBlockChildren(element);
WriteEndBlock(element);
Writer.WriteLine();
Writer.WriteLine();
}
/// <summary> /// Processes a namespace element. /// </summary> /// <param name="element">Namespace code element.</param> public abstract void VisitNamespaceElement(NamespaceElement element);
/// <summary>
/// Parses a namespace definition.
/// </summary>
/// <returns>Namespace code element.</returns>
private NamespaceElement ParseNamespace()
{
NamespaceElement namespaceElement = new NamespaceElement();
string namepaceName = CaptureWord();
namespaceElement.Name = namepaceName;
EatChar(CSharpSymbol.BeginBlock);
EatWhiteSpace();
if (NextChar != CSharpSymbol.EndBlock)
{
//
// Parse child elements
//
List<ICodeElement> childElements = ParseElements(namespaceElement);
foreach (ICodeElement childElement in childElements)
{
namespaceElement.AddChild(childElement);
}
}
EatChar(CSharpSymbol.EndBlock);
//
// Namespaces allow a trailing semi-colon
//
EatTrailingEndOfStatement();
return namespaceElement;
}
/// <summary>
/// Moves using directives if configured to do so.
/// </summary>
/// <param name="elements">List of top-level code elements.</param>
/// <param name="namespaceElement">Namespace namespace to use when moving usings.</param>
private void MoveUsings(List<ICodeElement> elements, NamespaceElement namespaceElement)
{
CodeLevel moveUsingsTo = _configuration.Formatting.Usings.MoveTo;
List<ICodeElement> tempElements;
if (moveUsingsTo != CodeLevel.None && namespaceElement != null)
{
if (moveUsingsTo == CodeLevel.Namespace)
{
tempElements = new List<ICodeElement>(elements);
for (int elementIndex = 0; elementIndex < tempElements.Count; elementIndex++)
{
UsingElement usingElement = tempElements[elementIndex] as UsingElement;
if (usingElement != null && usingElement.IsMovable)
{
if (elements.Contains(usingElement))
{
elements.Remove(usingElement);
}
tempElements.Remove(usingElement);
namespaceElement.InsertChild(0, usingElement);
elementIndex--;
}
else
{
if (tempElements[elementIndex] is RegionElement ||
tempElements[elementIndex] is GroupElement)
{
tempElements.AddRange(tempElements[elementIndex].Children);
}
else if (tempElements[elementIndex] is ConditionDirectiveElement)
{
ConditionDirectiveElement condition = tempElements[elementIndex] as ConditionDirectiveElement;
while (condition != null)
{
if (namespaceElement.Parent == condition)
{
tempElements.AddRange(tempElements[elementIndex].Children);
break;
}
condition = condition.ElseCondition;
}
}
}
}
}
else if (moveUsingsTo == CodeLevel.File)
{
tempElements = new List<ICodeElement>();
for (int elementIndex = 0; elementIndex < namespaceElement.Children.Count; elementIndex++)
{
UsingElement usingElement = namespaceElement.Children[elementIndex] as UsingElement;
if (usingElement != null && usingElement.IsMovable)
{
namespaceElement.RemoveChild(usingElement);
elements.Insert(0, usingElement);
elementIndex--;
}
else if (namespaceElement.Children[elementIndex] is RegionElement ||
namespaceElement.Children[elementIndex] is GroupElement)
{
foreach (ICodeElement childElement in namespaceElement.Children[elementIndex].Children)
{
if (childElement is UsingElement ||
childElement is RegionElement ||
childElement is GroupElement)
{
tempElements.Add(childElement);
}
}
}
}
for (int elementIndex = 0; elementIndex < tempElements.Count; elementIndex++)
{
UsingElement usingElement = tempElements[elementIndex] as UsingElement;
if (usingElement != null && usingElement.IsMovable)
{
tempElements.Remove(usingElement);
elements.Insert(0, usingElement);
elementIndex--;
}
else if (tempElements[elementIndex] is RegionElement ||
tempElements[elementIndex] is GroupElement)
{
tempElements.AddRange(tempElements[elementIndex].Children);
}
}
}
else
{
throw new ArgumentOutOfRangeException(
string.Format(
"Unknown code level '{0}'.",
moveUsingsTo));
}
}
}
public void MoveUsingsToNamespaceTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
UsingElement using1 = new UsingElement();
using1.Name = "System";
using1.IsMovable = true;
codeElements.Add(using1);
// Nested region and groups
RegionElement region = new RegionElement();
region.Name = "Region";
codeElements.Add(region);
GroupElement group = new GroupElement();
group.Name = "Group";
region.AddChild(group);
UsingElement using2 = new UsingElement();
using2.Name = "System.IO";
using2.IsMovable = true;
group.AddChild(using2);
NamespaceElement namespaceElement = new NamespaceElement();
namespaceElement.Name = "TestNamespace";
codeElements.Add(namespaceElement);
UsingElement using3 = new UsingElement();
using3.Name = "System.Collections";
using3.IsMovable = true;
namespaceElement.AddChild(using3);
TypeElement class1 = new TypeElement();
class1.Name = "Class1";
namespaceElement.AddChild(class1);
TypeElement class2 = new TypeElement();
class2.Name = "Class2";
namespaceElement.AddChild(class2);
CodeConfiguration configuration = CodeConfiguration.Default.Clone() as CodeConfiguration;
CodeArranger arranger;
//
// Move to namespace.
//
configuration.Formatting.Usings.MoveTo = CodeLevel.Namespace;
arranger = new CodeArranger(configuration);
ReadOnlyCollection<ICodeElement> arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(2, arranged.Count, "After arranging, an unexpected number of elements were returned.");
NamespaceElement namespaceElementTest = arranged[1] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(2, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
GroupElement namespaceGroup = namespaceElementTest.Children[0] as GroupElement;
Assert.IsNotNull(namespaceGroup);
GroupElement innerGroup = namespaceGroup.Children[0] as GroupElement;
Assert.AreEqual("System", innerGroup.Children[0].Name);
Assert.AreEqual("System.Collections", innerGroup.Children[1].Name);
Assert.AreEqual("System.IO", innerGroup.Children[2].Name);
RegionElement typeRegion = namespaceElementTest.Children[1] as RegionElement;
Assert.IsNotNull(typeRegion);
Assert.AreEqual("Class1", typeRegion.Children[0].Name);
Assert.AreEqual("Class2", typeRegion.Children[1].Name);
}
public void MoveUsingsBasicTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
UsingElement using1 = new UsingElement();
using1.Name = "System";
using1.IsMovable = true;
UsingElement using2 = new UsingElement();
using2.Name = "System.IO";
using2.IsMovable = true;
UsingElement using3 = new UsingElement();
using3.Name = "System.Collections";
using3.IsMovable = true;
codeElements.Add(using1);
codeElements.Add(using2);
NamespaceElement namespaceElement = new NamespaceElement();
namespaceElement.Name = "TestNamespace";
namespaceElement.AddChild(using3);
codeElements.Add(namespaceElement);
CodeConfiguration configuration = CodeConfiguration.Default.Clone() as CodeConfiguration;
CodeArranger arranger;
//
// Do not move.
//
configuration.Formatting.Usings.MoveTo = CodeLevel.None;
arranger = new CodeArranger(configuration);
ReadOnlyCollection<ICodeElement> arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(2, arranged.Count, "After arranging, an unexpected number of elements were returned.");
GroupElement fileGroup = arranged[0] as GroupElement;
Assert.IsNotNull(fileGroup);
GroupElement innerGroup = fileGroup.Children[0] as GroupElement;
Assert.AreEqual("System", innerGroup.Children[0].Name);
Assert.AreEqual("System.IO", innerGroup.Children[1].Name);
NamespaceElement namespaceElementTest = arranged[1] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(1, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
GroupElement namespaceGroup = namespaceElementTest.Children[0] as GroupElement;
Assert.IsNotNull(namespaceGroup);
innerGroup = namespaceGroup.Children[0] as GroupElement;
Assert.AreEqual("System.Collections", innerGroup.Children[0].Name);
//
// Move to file level;
//
configuration.Formatting.Usings.MoveTo = CodeLevel.File;
arranger = new CodeArranger(configuration);
arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(2, arranged.Count, "After arranging, an unexpected number of elements were returned.");
fileGroup = arranged[0] as GroupElement;
Assert.IsNotNull(fileGroup);
innerGroup = fileGroup.Children[0] as GroupElement;
Assert.AreEqual("System", innerGroup.Children[0].Name);
Assert.AreEqual("System.Collections", innerGroup.Children[1].Name);
Assert.AreEqual("System.IO", innerGroup.Children[2].Name);
namespaceElementTest = arranged[1] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
//
// Move to namespace.
//
configuration.Formatting.Usings.MoveTo = CodeLevel.Namespace;
arranger = new CodeArranger(configuration);
arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
namespaceElementTest = arranged[0] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(1, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
namespaceGroup = namespaceElementTest.Children[0] as GroupElement;
Assert.IsNotNull(namespaceGroup);
innerGroup = namespaceGroup.Children[0] as GroupElement;
Assert.AreEqual("System", innerGroup.Children[0].Name);
Assert.AreEqual("System.Collections", innerGroup.Children[1].Name);
Assert.AreEqual("System.IO", innerGroup.Children[2].Name);
//
// Move back to file level;
//
configuration.Formatting.Usings.MoveTo = CodeLevel.File;
arranger = new CodeArranger(configuration);
arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(2, arranged.Count, "After arranging, an unexpected number of elements were returned.");
fileGroup = arranged[0] as GroupElement;
Assert.IsNotNull(fileGroup);
innerGroup = fileGroup.Children[0] as GroupElement;
Assert.AreEqual("System", innerGroup.Children[0].Name);
Assert.AreEqual("System.Collections", innerGroup.Children[1].Name);
Assert.AreEqual("System.IO", innerGroup.Children[2].Name);
namespaceElementTest = arranged[1] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
}
public void DefaultArrangeStructLayoutTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
TypeElement structElement = new TypeElement();
structElement.Type = TypeElementType.Structure;
structElement.Access = CodeAccess.Public;
structElement.Name = "TestStructure";
structElement.AddAttribute(new AttributeElement("System.Runtime.InteropServices.StructLayout"));
NamespaceElement namespaceElement = new NamespaceElement();
namespaceElement.Name = "TestNamespace";
namespaceElement.AddChild(structElement);
FieldElement fieldElement1 = new FieldElement();
fieldElement1.Type = "int";
fieldElement1.Access = CodeAccess.Public;
fieldElement1.Name = "z";
structElement.AddChild(fieldElement1);
FieldElement fieldElement2 = new FieldElement();
fieldElement2.Type = "int";
fieldElement2.Access = CodeAccess.Public;
fieldElement2.Name = "x";
structElement.AddChild(fieldElement2);
FieldElement fieldElement3 = new FieldElement();
fieldElement3.Type = "int";
fieldElement3.Access = CodeAccess.Public;
fieldElement3.Name = "y";
structElement.AddChild(fieldElement3);
codeElements.Add(namespaceElement);
CodeArranger arranger = new CodeArranger(CodeConfiguration.Default);
ReadOnlyCollection<ICodeElement> arranged =
arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
NamespaceElement namespaceElementTest = arranged[0] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(1, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
RegionElement typeRegionElement = namespaceElementTest.Children[0] as RegionElement;
Assert.IsNotNull(typeRegionElement, "Expected a region element.");
Assert.AreEqual("Types", typeRegionElement.Name);
Assert.AreEqual(1, typeRegionElement.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
TypeElement typeElement = typeRegionElement.Children[0] as TypeElement;
Assert.IsNotNull(typeElement, "Expected a type element.");
Assert.AreEqual(TypeElementType.Structure, typeElement.Type, "Unexpected type element type.");
Assert.AreEqual(structElement.Name, typeElement.Name, "Unexpected type element name.");
Assert.AreEqual(1, typeElement.Children.Count, "An unexpected number of class child elements were returned.");
RegionElement regionElement = typeElement.Children[0] as RegionElement;
Assert.IsNotNull(regionElement, "Expected a region element but was {0}.", regionElement.ElementType);
Assert.AreEqual("Fixed Fields", regionElement.Name, "Unexpected region name.");
Assert.AreEqual(3, regionElement.Children.Count, "Unexpected number of region child elements.");
// The fields should not have been sorted
Assert.AreEqual(fieldElement1.Name, regionElement.Children[0].Name);
Assert.AreEqual(fieldElement2.Name, regionElement.Children[1].Name);
Assert.AreEqual(fieldElement3.Name, regionElement.Children[2].Name);
}
public void DefaultArrangeSimpleClassTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
TypeElement classElement = new TypeElement();
classElement.Type = TypeElementType.Class;
classElement.Access = CodeAccess.Public;
classElement.Name = "TestClass";
NamespaceElement namespaceElement = new NamespaceElement();
namespaceElement.Name = "TestNamespace";
namespaceElement.AddChild(classElement);
MethodElement methodElement = new MethodElement();
methodElement.Type = "void";
methodElement.Access = CodeAccess.Public;
methodElement.Name = "DoSomething";
classElement.AddChild(methodElement);
FieldElement fieldElement = new FieldElement();
fieldElement.Type = "bool";
fieldElement.Access = CodeAccess.Private;
fieldElement.Name = "_val";
classElement.AddChild(fieldElement);
PropertyElement propertyElement = new PropertyElement();
propertyElement.Type = "bool";
propertyElement.Access = CodeAccess.Public;
propertyElement.Name = "Value";
propertyElement.BodyText = "return _val";
classElement.AddChild(propertyElement);
codeElements.Add(namespaceElement);
CodeArranger arranger = new CodeArranger(CodeConfiguration.Default);
ReadOnlyCollection<ICodeElement> arranged =
arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
NamespaceElement namespaceElementTest = arranged[0] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(1, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
RegionElement typeRegionElement = namespaceElementTest.Children[0] as RegionElement;
Assert.IsNotNull(typeRegionElement, "Expected a region element.");
Assert.AreEqual("Types", typeRegionElement.Name);
Assert.AreEqual(1, typeRegionElement.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
TypeElement typeElement = typeRegionElement.Children[0] as TypeElement;
Assert.IsNotNull(typeElement, "Expected a type element.");
Assert.AreEqual(TypeElementType.Class, typeElement.Type, "Unexpected type element type.");
Assert.AreEqual(classElement.Name, typeElement.Name, "Unexpected type element name.");
Assert.AreEqual(3, typeElement.Children.Count, "An unexpected number of class child elements were returned.");
List<RegionElement> regionElements = new List<RegionElement>();
foreach (ICodeElement classChildElement in typeElement.Children)
{
RegionElement regionElement = classChildElement as RegionElement;
Assert.IsNotNull(
regionElement, "Expected a region element but was {0}.", classChildElement.ElementType);
regionElements.Add(regionElement);
}
Assert.AreEqual("Fields", regionElements[0].Name, "Unexpected region element name.");
Assert.AreEqual("Properties", regionElements[1].Name, "Unexpected region element name.");
Assert.AreEqual("Methods", regionElements[2].Name, "Unexpected region element name.");
GroupElement fieldGroupElement = regionElements[0].Children[0].Children[0] as GroupElement;
Assert.IsNotNull(fieldGroupElement, "Expected a group element for fields.");
foreach (ICodeElement codeElement in fieldGroupElement.Children)
{
FieldElement fieldElementTest = codeElement as FieldElement;
Assert.IsNotNull(
fieldElementTest,
"Expected a field element but was type {0}: {1}",
codeElement.ElementType,
codeElement);
}
Assert.AreEqual(1, regionElements[1].Children.Count);
foreach (ICodeElement codeElement in regionElements[1].Children[0].Children)
{
PropertyElement propertyElementTest = codeElement as PropertyElement;
Assert.IsNotNull(
propertyElementTest,
"Expected a property element but was type {0}: {1}",
codeElement.ElementType,
codeElement);
}
Assert.AreEqual(1, regionElements[2].Children.Count);
foreach (ICodeElement codeElement in regionElements[2].Children[0].Children)
{
MethodElement methodElementTest = codeElement as MethodElement;
Assert.IsNotNull(
methodElementTest,
"Expected a method element but was type {0}: {1}",
codeElement.ElementType,
codeElement);
}
}
public void DefaultArrangeEnumerationTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
UsingElement usingElement = new UsingElement();
usingElement.Name = "System";
TypeElement enumElement = new TypeElement();
enumElement.Type = TypeElementType.Enum;
enumElement.Access = CodeAccess.Public;
enumElement.Name = "TestEnum";
enumElement.BodyText = "Value1 = 1,\r\nValue2 = 2";
NamespaceElement namespaceElement = new NamespaceElement();
namespaceElement.Name = "TestNamespace";
namespaceElement.AddChild(usingElement);
namespaceElement.AddChild(enumElement);
codeElements.Add(namespaceElement);
CodeArranger arranger = new CodeArranger(CodeConfiguration.Default);
ReadOnlyCollection<ICodeElement> arranged =
arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
NamespaceElement namespaceElementTest = arranged[0] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(2, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
Assert.AreEqual(ElementType.Using, namespaceElement.Children[0].ElementType);
RegionElement regionElement = namespaceElementTest.Children[1] as RegionElement;
Assert.IsNotNull(regionElement, "Expected a region element.");
Assert.AreEqual("Enumerations", regionElement.Name, "Unexpected region name.");
Assert.AreEqual(1, regionElement.Children.Count,
"After arranging, an unexpected number of region elements were returned.");
TypeElement typeElement = regionElement.Children[0] as TypeElement;
Assert.IsNotNull(typeElement, "Expected a type element.");
Assert.AreEqual(TypeElementType.Enum, typeElement.Type, "Unexpected type element type.");
Assert.AreEqual(enumElement.Name, typeElement.Name, "Unexpected type element name.");
}