private Field(Field fieldToCopyFrom) : base(null) { fieldToCopyFrom.CloneInto(this); DataType = fieldToCopyFrom.DataType.Clone(); Modifiers = new List<string>(fieldToCopyFrom.Modifiers); InitialValue = fieldToCopyFrom.InitialValue; }
protected CodeRoot CreateFieldAndClass(string fieldName, out Field createdField) { createdField = new Field(controller); createdField.Name = fieldName; createdField.Modifiers.Add("public"); createdField.DataType = new DataType(controller, "int"); createdField.InitialValue = "5"; CodeRoot userRoot = CreateClassAndNamespace(createdField); return(userRoot); }
public void Field() { Field inter = new Field(controller); inter.Name = "i"; inter.Modifiers.Add("public"); inter.DataType = new DataType(controller, "int"); inter.InitialValue = "1"; CodeRoot root = CreateClassAndNamespace(inter); CodeRootMap map = new CodeRootMap(); map.AddCodeRoot(root, Version.User); map.AddCodeRoot(root, Version.NewGen); map.AddCodeRoot(root, Version.PrevGen); string result = map.GetMergedCodeRoot().ToString(); Assert.That(result, Is.EqualTo(root.ToString())); Assertions.StringContains(result, "class Class1"); Assertions.StringContains(result, "[Serializable(true)]"); Assertions.StringContains(result, "namespace ArchAngel.Tests"); Assertions.StringContains(result, "public int i = 1"); }
private static void ApplyTypeChanges(Field existingField, Field exampleField, Actions actions) { if (exampleField.DataType != null && existingField.DataType.Equals(exampleField.DataType) == false) { // Change datatype actions.AddAction(new ChangeTypeOfFieldAction(existingField, exampleField.DataType)); } }
private static void ApplyModifierChanges(Field existingField, Field exampleField, Actions actions) { if (existingField.Modifiers.UnorderedEqual(exampleField.Modifiers) == false) { string modifierString = ""; foreach (var mod in existingField.Modifiers) modifierString += mod + " "; modifierString = modifierString.Trim(); actions.AddAction(new RemoveModifierFromFieldAction(existingField, modifierString)); foreach (var modifier in exampleField.Modifiers) actions.AddAction(new AddModifierToFieldAction(existingField, modifier, false)); } }
private static void ApplyFieldDeletion(Actions actions, Field existingField) { actions.AddAction(new RemoveFieldFromClassAction(existingField)); }
private bool IsTheSame(Field comparisonField) { return IsTheSame(comparisonField, ComparisonDepth.Signature); }
public ChangeTypeOfFieldAction(Field fieldToChange, DataType newName) { FieldToChange = fieldToChange; NewType = newName; }
private void Process_Field_Declaration(FieldDeclaration node) { if (node == null) throw new ArgumentNullException("node"); foreach (IAstNode comment in node.Comments) { comments.Add(comment.StartOffset, (Comment)comment); } foreach (IAstNode fieldNode in node.Variables) { VariableDeclarator v = fieldNode as VariableDeclarator; if (v != null && v.ReturnType.TextRange.EndOffset > v.ReturnType.TextRange.StartOffset) { Field field = new Field(controller); field.Name = v.Name.Text; field.Modifiers.AddRange(FormatterUtility.GetModifiersFromEnum(v.Modifiers)); if (v.IsConstant) { field.Modifiers.Add("const"); } field.InitialValue = formatter.FormatExpression(v.Initializer); //try //{ field.DataType = FormatterUtility.GetDataTypeFromTypeReference(v.ReturnType, document, controller); //} //catch //{ // // Do nothing, DataType should be empty string //} SetupBaseConstruct(v.StartOffset, v.EndOffset, v.DocumentationProvider.Documentation, field, node.AttributeSections); // Pop the stack here as there may be multiple Field declarations. objectStack.Pop(); } } }
private void Process_Field_Declaration(FieldDeclaration node) { if (node == null) throw new ArgumentNullException("node"); foreach (IAstNode comment in node.Comments) comments.Add(comment.StartOffset, (Comment)comment); int counter = 0; for (int i = 0; i < node.Variables.Count; i++) { IAstNode fieldNode = node.Variables[i]; VariableDeclarator v = fieldNode as VariableDeclarator; if (v != null) { Field field = new Field(controller); field.Name = v.Name.Text; field.Modifiers.AddRange(FormatterUtility.GetModifiersFromEnum(v.Modifiers)); if (v.IsConstant) { field.Modifiers.Add("const"); } field.InitialValue = formatter.FormatExpression(v.Initializer); field.DataType = FormatterUtility.GetDataTypeFromTypeReference(v.ReturnType, document, controller); if (counter == 0) SetupBaseConstruct(node.TextRange.StartOffset, v.EndOffset, v.DocumentationProvider.Documentation, field, node.AttributeSections); else SetupBaseConstruct(v.StartOffset, v.EndOffset, v.DocumentationProvider.Documentation, field, node.AttributeSections); counter++; // Pop the stack here as there may be multiple Field declarations. objectStack.Pop(); } } }
protected CodeRoot CreateFieldAndClass(string fieldName, out Field createdField) { createdField = new Field(controller); createdField.Name = fieldName; createdField.Modifiers.Add("public"); createdField.DataType = new DataType(controller, "int"); createdField.InitialValue = "5"; CodeRoot userRoot = CreateClassAndNamespace(createdField); return userRoot; }
public void Field() { Field inter = new Field(controller); inter.Name = "i"; inter.Modifiers.Add("public"); inter.DataType = new DataType(controller,"int"); inter.InitialValue = "1"; CodeRoot root = CreateClassAndNamespace(inter); CodeRootMap map = new CodeRootMap(); map.AddCodeRoot(root, Version.User); map.AddCodeRoot(root, Version.NewGen); map.AddCodeRoot(root, Version.PrevGen); string result = map.GetMergedCodeRoot().ToString(); Assert.That(result, Is.EqualTo(root.ToString())); Assertions.StringContains(result, "class Class1"); Assertions.StringContains(result, "[Serializable(true)]"); Assertions.StringContains(result, "namespace ArchAngel.Tests"); Assertions.StringContains(result, "public int i = 1"); }
public VBFieldPrinter(Field obj) { this.obj = obj; }
public ChangeNameOfFieldAction(Field fieldToChange, string newName) { FieldToChange = fieldToChange; NewName = newName; }
public RemoveModifierFromFieldAction(Field fieldToChange, string modifierToRemove) { FieldToChange = fieldToChange; ModifierToRemove = modifierToRemove; }
public RemoveFieldFromClassAction(Field fieldToDelete) { FieldToDelete = fieldToDelete; }
public void Field_Changed_Return_Type() { const string name = "MyField1"; string expectedResult = String.Format("{0} {1} {2}", Modifier1, DataType2, name); DataType type1 = new DataType(controller, DataType1); DataType type2 = new DataType(controller, DataType2); Field merged1 = new Field(controller); Field merged2 = new Field(controller); Field merged3 = new Field(controller); Field changing = new Field(controller, type2, name, Modifier1); Field unchanging = new Field(controller, type1, name, Modifier1); Merge_And_Assert(merged1, merged2, merged3, changing, unchanging, expectedResult); }
public void Field() { Field inter = new Field(controller); inter.Name = "i"; inter.Modifiers.Add("public"); inter.DataType = new DataType(controller, "int"); inter.InitialValue = "1"; Assert.That(inter.IsTheSame(inter.Clone(), ComparisonDepth.Outer), Is.True); }
public AddAttributeToFieldAction(Field fieldToAddTo, Attribute attributeToAdd) { FieldToAddTo = fieldToAddTo; AttributeToAdd = attributeToAdd; }
public void Field() { Field item = new Field(controller, new DataType(controller, "int"), "Field1", "public"); Assert.That(item.FullyQualifiedDisplayName, Is.EqualTo("Field1")); Class cl = new Class(controller, "Class1"); cl.AddChild(item); Assert.That(item.FullyQualifiedDisplayName, Is.EqualTo("Class1.Field1")); }
public AddModifierToFieldAction(Field fieldToChange, string newModifier, bool insertAtStart) { FieldToChange = fieldToChange; NewModifier = newModifier; InsertAtStart = insertAtStart; }
public static int GetFieldNameIndex(string textToSearch, Field baseConstruct, int searchStart, int searchEnd) { //searchEnd = textToSearch.IndexOf('{', searchStart); return textToSearch.IndexOf(baseConstruct.Name, searchStart, searchEnd - searchStart); }
private bool IsTheSame(Field comparisonField, ComparisonDepth depth) { if (comparisonField == null) return false; if (Name == comparisonField.Name) { // TODO: Why are these checks on parents here? // if (ParentObject.IsTheSame(comparisonField.ParentObject)) { if (depth == ComparisonDepth.Signature) { return true; } if (!base.IsTheSame(comparisonField, depth)) { return false; } if (!Utility.StringCollectionsAreTheSame(Modifiers, comparisonField.Modifiers)) { ComparisonDifference += GetType().Name + ".Modifiers"; return false; } if (DataType != comparisonField.DataType) return false; if (depth == ComparisonDepth.Outer) { return true; } if (InitialValue != comparisonField.InitialValue) { ComparisonDifference += GetType().Name + ".InitialValue"; return false; } return true; } } return false; }
public ChangeInitialValueOfFieldAction(Field fieldToChange, string newInitialValue) { FieldToChange = fieldToChange; NewInitialValue = newInitialValue; }
private static void ApplyFieldChanges(Actions actions, Field existingField, Field exampleField) { ApplyNameChanges(existingField, exampleField, actions); ApplyModifierChanges(existingField, exampleField, actions); ApplyInitialValueChanges(existingField, exampleField, actions); ApplyTypeChanges(existingField, exampleField, actions); }
public void Field_Added_Modifier() { const string name = "MyField1"; DataType type1 = new DataType(controller, DataType1); string expectedResult = String.Format("{0} {1} {2} {3}", Modifier1, Modifier2, type1, name); Field merged1 = new Field(controller); Field merged2 = new Field(controller); Field merged3 = new Field(controller); Field changing = new Field(controller, type1, name, Modifier1); changing.Modifiers.Add(Modifier2); Field unchanging = new Field(controller, type1, name, Modifier1); Merge_And_Assert(merged1, merged2, merged3, changing, unchanging, expectedResult); }
private static void ApplyInitialValueChanges(Field existingField, Field exampleField, Actions actions) { if (exampleField.InitialValue != null && existingField.InitialValue.Equals(exampleField.InitialValue) == false) { // Change initial value actions.AddAction(new ChangeInitialValueOfFieldAction(existingField, exampleField.InitialValue)); } }
public void Field_Added_Preceeding_Comments() { const string name = "MyField1"; const string comment1 = "My first comment goes here..."; const string comment2 = "My second comment goes here..."; const string comment3 = "My third comment goes here..."; string expectedResult = String.Format("{0}\n{1}\n{2}".Replace("\n",Environment.NewLine),comment1,comment2,comment3); DataType type1 = new DataType(controller, DataType1); Field merged1 = new Field(controller); Field merged2 = new Field(controller); Field merged3 = new Field(controller); Field changing = new Field(controller, type1, name, Modifier1); changing.Comments.PreceedingComments.Add(comment1); changing.Comments.PreceedingComments.Add(comment2); changing.Comments.PreceedingComments.Add(comment3); Field unchanging = new Field(controller, type1, name, Modifier1); Merge_And_Assert(merged1, merged2, merged3, changing, unchanging, expectedResult); }
private static void ApplyNameChanges(Field existingField, Field exampleField, Actions actions) { if (existingField.Name != exampleField.Name) { // Change name actions.AddAction(new ChangeNameOfFieldAction(existingField, exampleField.Name)); } }
public void Field_Added_Trailing_Comment() { const string name = "MyField1"; const string comment = "My comment goes here..."; DataType type1 = new DataType(controller, DataType1); Field merged1 = new Field(controller); Field merged2 = new Field(controller); Field merged3 = new Field(controller); Field changing = new Field(controller, type1, name, Modifier1); changing.Comments.TrailingComment = comment; Field unchanging = new Field(controller, type1, name, Modifier1); Merge_And_Assert(merged1, merged2, merged3, changing, unchanging, comment); }
private Field Construct(Class @class) { Field field = new Field(@class.Controller); field.Name = _name; field.Modifiers.AddRange(_Modifiers); field.DataType = new DataType(@class.Controller, _typeName); field.InitialValue = _initialValue; return field; }
public AddFieldToClassAction(Field fieldToAdd, AdditionPoint additionPoint, Class classToAddTo) { ConstructToAdd = FieldToAdd = fieldToAdd; AdditionPoint = additionPoint; ClassToAddTo = classToAddTo; }