private bool Match(StatementCollection statements)
{
this.statements = statements;
yieldDeclaringType = GetGeneratedType();
if (yieldDeclaringType == null)
{
return false;
}
IEnumerable<Statement> moveNextMethodStatements = GetStatements();
if (moveNextMethodStatements == null || yieldData == null)
{
return false;
}
if (statements.Count > 2)
{
SetParameterMappings();
StatementCollection getEnumeratorStatements = GetEnumeratorStatements();
if (getEnumeratorStatements != null)
{
PostProcessMappings(getEnumeratorStatements);
}
}
newStatements = new StatementCollection();
foreach (Statement statement in moveNextMethodStatements)
{
newStatements.Add(statement);
}
return true;
}
private StatementCollection GetStatementsForInvocation(out int endIndex, out int startIndex, out bool isBaseCtor)
{
startIndex = 0;
StatementCollection bodyStatements = methodBodyBlock.Statements;
StatementCollection statements = new StatementCollection();
isBaseCtor = false;
int index = 0;
for (; index < bodyStatements.Count; index++)
{
if (IsVariableDeclaration(bodyStatements[index]) && statements.Count == 0)
{
startIndex++;
continue;
}
statements.Add(bodyStatements[index].Clone());
if (IsCtorInvocation(bodyStatements[index], out isBaseCtor))
{
if (isBaseCtor)
{
methodContext.IsBaseConstructorInvokingConstructor = true;
}
break;
}
}
endIndex = index;
if (index == bodyStatements.Count)
{
endIndex = -1;
statements = null;
}
return statements;
}
public void ShouldAddToCollection(IFixture fixture)
{
var sut = new StatementCollection(new List <IStatement>());
sut.Add(fixture.Create <IStatement>());
sut.Statements.Should().HaveCount(1);
}
public void ToCodeDomFull(StatementCollection sts)
{
// create enumrator and initialize it
sts.Add(Stm.Comment("<foreach>"));
sts.Add(Stm.Comment("This loop mimics a foreach call. See C# programming language, pg 247"));
sts.Add(Stm.Comment("Here, the enumerator is seale and does not implement IDisposable"));
VariableDeclarationStatement enDecl = Stm.Var(
typeof(IEnumerator),
"enumerator",
this.Collection.Method("GetEnumerator").Invoke()
);
sts.Add(enDecl);
// get expression
VariableReferenceExpression en = Expr.Var(enDecl);
// iterate
IterationStatement iter = Stm.While(en.Method("MoveNext").Invoke());
sts.Add(iter);
// get local parameter
VariableDeclarationStatement localDecl = Stm.Var(
this.LocalType,
this.LocalName
);
localDecl.InitExpression = (en.Prop("Current")).Cast(this.LocalType);
iter.Statements.Add(localDecl);
// add statements
iter.Statements.Add(Stm.Comment("foreach body"));
iter.Statements.AddRange(this.body);
sts.Add(Stm.Comment("</foreach>"));
}
protected CodeBlockStatement(SerializationInfo info)
: base(info)
{
Label = info.GetString("label");
Statements = new StatementCollection(this);
var statements = info.GetValue <SqlStatement[]>("statements");
foreach (var statement in statements)
{
Statements.Add(statement);
}
}
private ICollection <SqlStatement> DeserializeObjects(SerializationInfo info)
{
var count = info.GetInt32("Statements.Count");
var list = new StatementCollection(this);
for (int i = 0; i < count; i++)
{
var statement = (SqlStatement)info.GetValue(String.Format("Statement[{0}]", i), typeof(SqlStatement));
list.Add(statement);
}
return(list);
}
public static StatementCollection Parse(string content)
{
var statements = new StatementCollection();
statements.Balance = _balance;
var doc = new HtmlDocument();
doc.LoadHtml(content);
var rows = doc.DocumentNode.SelectNodes("/html[1]/body[1]/div[1]/div[4]/div[1]/div[2]/table[1]/tbody[1]/tr[position()>1]");
if (rows != null)
{
for (int i = 0; i < rows.Count - 2; i++)
{
var row = rows[i];
var fields = row.SelectNodes("./td");
if (fields == null)
{
continue;
}
// data/transaction/debit/credit/balance
if (fields.Count == 5)
{
var statement = new Statement();
statement.ID = RemoveComma(CryptographyHelper.MD5(row.InnerHtml));
statement.Date = RemoveComma(ContentHelper.Clear(fields[0].InnerHtml, " "));
statement.Description = RemoveComma(ContentHelper.Clear(fields[1].InnerHtml, " "));
statement.Debit = ContentHelper.Clear(fields[2].InnerHtml).Replace(".", "").Replace(",", ".");
statement.Credit = ContentHelper.Clear(fields[3].InnerHtml).Replace(".", "").Replace(",", ".");
statement.Balance = ContentHelper.Clear(fields[4].InnerHtml).Replace(".", "").Replace(",", ".");
statements.Add(statement);
}
}
}
statements.Balance = (statements[statements.Count - 1] as Statement).Balance;
return(statements);
}
private StatementCollection GetStatementsForInvocation(out int endIndex, out int startIndex, out bool isBaseCtor)
{
startIndex = 0;
StatementCollection bodyStatements = methodBodyBlock.Statements;
StatementCollection statements = new StatementCollection();
isBaseCtor = false;
int index = 0;
for (; index < bodyStatements.Count; index++)
{
if (IsVariableDeclaration(bodyStatements[index]) && statements.Count == 0)
{
startIndex++;
continue;
}
statements.Add(bodyStatements[index].Clone());
if (IsCtorInvocation(bodyStatements[index], out isBaseCtor))
{
if (isBaseCtor)
{
methodContext.IsBaseConstructorInvokingConstructor = true;
}
break;
}
}
endIndex = index;
if (index == bodyStatements.Count)
{
endIndex = -1;
statements = null;
}
return(statements);
}
private StatementCollection GetStatementsForInvocation(out int endIndex, out int startIndex, out bool isBaseCtor)
{
startIndex = 0;
V_0 = this.methodBodyBlock.get_Statements();
V_1 = new StatementCollection();
isBaseCtor = false;
V_2 = 0;
while (V_2 < V_0.get_Count())
{
if (!this.IsVariableDeclaration(V_0.get_Item(V_2)) || V_1.get_Count() != 0)
{
V_1.Add(V_0.get_Item(V_2).Clone());
if (this.IsCtorInvocation(V_0.get_Item(V_2), out isBaseCtor))
{
if (!isBaseCtor)
{
break;
}
this.methodContext.set_IsBaseConstructorInvokingConstructor(true);
break;
}
}
else
{
startIndex = startIndex + 1;
}
V_2 = V_2 + 1;
}
endIndex = V_2;
if (V_2 == V_0.get_Count())
{
endIndex = -1;
V_1 = null;
}
return(V_1);
}
private bool Match(StatementCollection statements)
{
this.statements = statements;
yieldDeclaringType = GetGeneratedType();
if (yieldDeclaringType == null)
{
return(false);
}
IEnumerable <Statement> moveNextMethodStatements = GetStatements();
if (moveNextMethodStatements == null || yieldData == null)
{
return(false);
}
if (statements.Count > 2)
{
SetParameterMappings();
StatementCollection getEnumeratorStatements = GetEnumeratorStatements();
if (getEnumeratorStatements != null)
{
PostProcessMappings(getEnumeratorStatements);
}
}
newStatements = new StatementCollection();
foreach (Statement statement in moveNextMethodStatements)
{
newStatements.Add(statement);
}
return(true);
}
/// <summary>
/// Coppies the block that is targeted from the goto if it matches the case
///
/// ... some code
/// goto: label0;
///
/// ...
/// ...
/// label0: statement1
/// *statements*
/// return;
/// ...
/// </summary>
/// <param name="labeledStatement">The targeted statement.</param>
/// <param name="gotoStatement">The goto statement.</param>
/// <returns>Returns True if the targeted block was coppied.</returns>
private bool TryCopyTargetedBlock(Statement labeledStatement, GotoStatement gotoStatement)
{
StatementCollection toCopy = new StatementCollection();
StatementCollection originalStatements = new StatementCollection();
BlockStatement targetParent = labeledStatement.Parent as BlockStatement;
if (targetParent == null)
{
return false;
}
int targetIndex = targetParent.Statements.IndexOf(labeledStatement);
originalStatements.Add(labeledStatement);
Statement labeledClone = labeledStatement.CloneStatementOnly();
labeledClone.Label = string.Empty;
toCopy.Add(labeledClone);
int maxStatementsToCopy = MaximumStatementsToCopy;
if (ContainsLabel(labeledClone))
{
return false;
}
maxStatementsToCopy -= GetStatementsCount(labeledClone);
if (maxStatementsToCopy < 0)
{
return false;
}
if (!IsReturnStatement(labeledClone) && !IsThrowStatement(labeledClone))
{
///Collect all statements, until a return is reached.
int index;
for (index = targetIndex + 1; index < targetParent.Statements.Count; index++)
{
Statement nextStatement = targetParent.Statements[index];
if (ContainsLabel(nextStatement))
{
return false;
}
maxStatementsToCopy -= GetStatementsCount(nextStatement);
if (maxStatementsToCopy < 0)
{
return false;
}
originalStatements.Add(nextStatement);
Statement clone = nextStatement.CloneStatementOnly();
toCopy.Add(clone);
if (IsReturnStatement(nextStatement) || IsThrowStatement(nextStatement))
{
break;
}
}
if (index == targetParent.Statements.Count)
{
///all the statements were traversed and no 'return' statement was found
return false;
}
}
///Move the coppied statements on the place of the goto statement.
MoveStatements(gotoStatement, toCopy);
///Clean up the label from the targeted statement if possible, and remove the targeted statement if it cannot be reached anymore
if (!Targeted(labeledStatement.Label))
{
UpdateUntargetedStatement(labeledStatement, originalStatements);
}
return true;
}
private void GenerateEntity(NamespaceDeclaration ns, Entity entity)
{
var type = ns.AddType(new ClassDeclaration(entity.Name));
AddDocumentationComments(type, entity.Documentation);
type.Modifiers = Modifiers.Public | Modifiers.Partial;
type.BaseType = entity.BaseType ?? ModelRef.GitLabObject;
// Add default constructor
var ctor = type.AddMember(new ConstructorDeclaration()
{
Arguments =
{
new MethodArgumentDeclaration(typeof(JObject), "obj")
},
Modifiers = Modifiers.Internal,
Initializer = new ConstructorBaseInitializer(new ArgumentReferenceExpression("obj"))
});
var internalCtor = type.AddMember(new ConstructorDeclaration()
{
Modifiers = Modifiers.Internal,
Initializer = new ConstructorBaseInitializer(new NewObjectExpression(typeof(JObject)))
});
// Add properties
foreach (var prop in entity.Properties)
{
var propertyMember = type.AddMember(new PropertyDeclaration(ToPropertyName(prop.Name), GetPropertyTypeRef(prop.Type))
{
Modifiers = Modifiers.Public,
Getter = new StatementCollection
{
new ReturnStatement(new ThisExpression().CreateInvokeMethodExpression("GetValueOrDefault",
new TypeReference[]
{
GetPropertyTypeRef(prop.Type)
},
new Expression[]
{
prop.SerializationName ?? prop.Name,
new DefaultValueExpression(GetPropertyTypeRef(prop.Type)),
}))
},
Setter = new PropertyAccessorDeclaration
{
Modifiers = Modifiers.Internal,
Statements = new StatementCollection
{
new ThisExpression().CreateInvokeMethodExpression("SetValue",
new Expression[]
{
prop.SerializationName ?? prop.Name,
new ValueArgumentExpression(),
})
}
},
});
AddDocumentationComments(propertyMember, prop.Documentation);
if (prop.Type == ModelRef.Date || prop.Type == ModelRef.NullableDate)
{
propertyMember.CustomAttributes.Add(new CustomAttribute(typeof(SkipUtcDateValidationAttribute))
{
Arguments = { new CustomAttributeArgument("Does not contain time nor timezone (e.g. 2018-01-01)") }
});
}
propertyMember.CustomAttributes.Add(new CustomAttribute(typeof(MappedPropertyAttribute))
{
Arguments = { new CustomAttributeArgument(prop.SerializationName ?? prop.Name) }
});
}
// Generate Equals members (Equals, GetHashCode, ==, !=, IEquatable<T>)
var displayProperty = entity.Properties.FirstOrDefault(p => p.IsDisplayName);
var keyProperties = entity.Properties.Where(p => p.IsKey).ToList();
if (keyProperties.Count > 0)
{
type.Implements.Add(new TypeReference(typeof(IEquatable <>)).MakeGeneric(type));
GenerateEqualMethod();
GenerateEqualTypedMethod();
GenerateGetHashCode();
GenerateEqualityOperator();
}
// Generate EntityDisplayName (DebuggerDisplay, ToString)
if (displayProperty != null)
{
GenerateDebuggerDisplay();
}
void GenerateEqualMethod()
{
var equal = type.AddMember(new MethodDeclaration(nameof(object.Equals)));
equal.Modifiers = Modifiers.Public | Modifiers.Override;
equal.ReturnType = typeof(bool);
var objArg = equal.AddArgument("obj", typeof(object));
var statements = new StatementCollection();
equal.Statements = statements;
var typedVariable = new VariableDeclarationStatement(type, "a", new ConvertExpression(objArg, type));
statements.Add(typedVariable);
statements.Add(new ReturnStatement(new ThisExpression().CreateInvokeMethodExpression("Equals", typedVariable)));
}
void GenerateEqualTypedMethod()
{
var equal = type.AddMember(new MethodDeclaration(nameof(object.Equals)));
equal.Modifiers = Modifiers.Public | Modifiers.Virtual;
equal.ReturnType = typeof(bool);
var objArg = equal.AddArgument("obj", type);
var returnExpression = new BinaryExpression(BinaryOperator.NotEquals, objArg, new LiteralExpression(null));
foreach (var key in keyProperties)
{
var typeRef = GetPropertyTypeRef(key.Type);
var expr = new BinaryExpression(BinaryOperator.Equals,
new ThisExpression().CreateMemberReferenceExpression(ToPropertyName(key.Name)),
objArg.CreateMemberReferenceExpression(ToPropertyName(key.Name)));
returnExpression = new BinaryExpression(BinaryOperator.And, returnExpression, expr);
}
equal.Statements = new ReturnStatement(returnExpression);
}
void GenerateGetHashCode()
{
var equal = type.AddMember(new MethodDeclaration(nameof(object.GetHashCode)));
equal.Modifiers = Modifiers.Public | Modifiers.Override;
equal.ReturnType = typeof(int);
var statements = new StatementCollection();
var hashCode = new VariableDeclarationStatement(typeof(int), "hashCode", new LiteralExpression(574293967));
statements.Add(hashCode);
foreach (var key in keyProperties)
{
var typeRef = Type.GetType(GetPropertyTypeRef(key.Type).ClrFullTypeName);
if (typeRef.IsValueType)
{
statements.Add(new AssignStatement(hashCode,
new BinaryExpression(BinaryOperator.Add,
new BinaryExpression(BinaryOperator.Multiply, hashCode, new LiteralExpression(-1521134295)),
new ThisExpression().CreateMemberReferenceExpression(ToPropertyName(key.Name)).CreateInvokeMethodExpression(nameof(GetHashCode)))));
}
else
{
statements.Add(new AssignStatement(hashCode,
new BinaryExpression(BinaryOperator.Add,
new BinaryExpression(BinaryOperator.Multiply, hashCode, new LiteralExpression(-1521134295)),
new TypeReference(typeof(EqualityComparer <>)).MakeGeneric(key.Type).CreateMemberReferenceExpression("Default").CreateInvokeMethodExpression("GetHashCode", ToPropertyName(key.Name)))));
}
}
statements.Add(new ReturnStatement(hashCode));
equal.Statements = statements;
}
void GenerateEqualityOperator()
{
var equal = type.AddMember(new OperatorDeclaration("=="));
equal.Modifiers = Modifiers.Public | Modifiers.Static;
equal.ReturnType = typeof(bool);
equal.Arguments.Add(new MethodArgumentDeclaration(type, "a"));
equal.Arguments.Add(new MethodArgumentDeclaration(type, "b"));
equal.Statements.Add(new ReturnStatement(new TypeReference(typeof(EqualityComparer <>)).MakeGeneric(type).CreateMemberReferenceExpression("Default").CreateInvokeMethodExpression("Equals",
new ArgumentReferenceExpression("a"),
new ArgumentReferenceExpression("b"))));
var notEqual = type.AddMember(new OperatorDeclaration("!="));
notEqual.Modifiers = Modifiers.Public | Modifiers.Static;
notEqual.ReturnType = typeof(bool);
notEqual.Arguments.Add(new MethodArgumentDeclaration(type, "a"));
notEqual.Arguments.Add(new MethodArgumentDeclaration(type, "b"));
notEqual.Statements.Add(new ReturnStatement(new UnaryExpression(UnaryOperator.Not, new BinaryExpression(BinaryOperator.Equals, new ArgumentReferenceExpression("a"), new ArgumentReferenceExpression("b")))));
}
void GenerateDebuggerDisplay()
{
var properties = new[] { displayProperty }.Concat(keyProperties).Where(p => p != null);
type.CustomAttributes.Add(new CustomAttribute(typeof(DebuggerDisplayAttribute))
{
Arguments =
{
new CustomAttributeArgument(new LiteralExpression("{GetType().Name,nq} " + string.Join(", ", properties.Select(v => $"{ToPropertyName(v.Name)}={{{ToPropertyName(v.Name)}}}")))),
}
});
}
}
/// <summary>
/// Coppies the block that is targeted from the goto if it matches the case
///
/// ... some code
/// goto: label0;
///
/// ...
/// ...
/// label0: statement1
/// *statements*
/// return;
/// ...
/// </summary>
/// <param name="labeledStatement">The targeted statement.</param>
/// <param name="gotoStatement">The goto statement.</param>
/// <returns>Returns True if the targeted block was coppied.</returns>
private bool TryCopyTargetedBlock(Statement labeledStatement, GotoStatement gotoStatement)
{
StatementCollection toCopy = new StatementCollection();
StatementCollection originalStatements = new StatementCollection();
BlockStatement targetParent = labeledStatement.Parent as BlockStatement;
if (targetParent == null)
{
return(false);
}
int targetIndex = targetParent.Statements.IndexOf(labeledStatement);
originalStatements.Add(labeledStatement);
Statement labeledClone = labeledStatement.CloneStatementOnly();
labeledClone.Label = string.Empty;
toCopy.Add(labeledClone);
int maxStatementsToCopy = MaximumStatementsToCopy;
if (ContainsLabel(labeledClone))
{
return(false);
}
maxStatementsToCopy -= GetStatementsCount(labeledClone);
if (maxStatementsToCopy < 0)
{
return(false);
}
if (!IsReturnStatement(labeledClone) && !IsThrowStatement(labeledClone))
{
///Collect all statements, until a return is reached.
int index;
for (index = targetIndex + 1; index < targetParent.Statements.Count; index++)
{
Statement nextStatement = targetParent.Statements[index];
if (ContainsLabel(nextStatement))
{
return(false);
}
maxStatementsToCopy -= GetStatementsCount(nextStatement);
if (maxStatementsToCopy < 0)
{
return(false);
}
originalStatements.Add(nextStatement);
Statement clone = nextStatement.CloneStatementOnly();
toCopy.Add(clone);
if (IsReturnStatement(nextStatement) || IsThrowStatement(nextStatement))
{
break;
}
}
if (index == targetParent.Statements.Count)
{
///all the statements were traversed and no 'return' statement was found
return(false);
}
}
///Move the coppied statements on the place of the goto statement.
MoveStatements(gotoStatement, toCopy);
///Clean up the label from the targeted statement if possible, and remove the targeted statement if it cannot be reached anymore
if (!Targeted(labeledStatement.Label))
{
UpdateUntargetedStatement(labeledStatement, originalStatements);
}
return(true);
}
