void it_works()
{
dynamic person = new Gemini();
person.Validates = new DynamicFunction(() =>
{
var validations = new List<dynamic>();
validations.Add(new Presence("FirstName"));
validations.Add(new Presence("Email"));
validations.Add(new Confirmation("Email"));
return validations;
});
new Validations(person);
Assert.IsFalse(person.IsValid());
Assert.AreEqual("FirstName is required.", person.Errors()[0].Value);
Assert.AreEqual("Email is required.", person.Errors()[1].Value);
person.FirstName = "Jane";
person.Email = "*****@*****.**";
person.EmailConfirmation = "*****@*****.**";
Assert.IsTrue(person.IsValid());
}
DynamicFunctionWithParam CreateCachedMethodFor(DynamicFunctionWithParam @delegate)
{
var methodName = (@delegate as Delegate).Method.Name;
var newDelegate = new DynamicFunctionWithParam(originalParameters =>
{
dynamic arguments = null;
if (originalParameters is Gemini) arguments = originalParameters.HashOfProperties();
else if (IsValueType(originalParameters)) arguments = originalParameters;
else arguments = new Gemini(originalParameters).HashOfProperties();
var cachedValue = null as object;
if (HasSameArgumgents(methodName, arguments, out cachedValue)) return cachedValue;
var result = (@delegate as Delegate).Method.Invoke(instance, new[] { originalParameters });
parameterizedFunctions.Add(
new KeyValuePair<MemoizedMethod, object>(
new MemoizedMethod { Name = methodName, Arguments = arguments },
result));
return result;
});
return newDelegate;
}
public static dynamic ToDynamic(object value)
{
if (value is JValue)
{
return((value as JValue).Value);
}
if (value is JObject)
{
var gemini = new Gemini();
foreach (var item in (value as JObject))
{
gemini.SetMember(item.Key, ToDynamic(item.Value));
}
return(gemini);
}
if (value is JArray)
{
return(ToArray(value as JArray));
}
return(value);
}
public void TestDemo6Introspection()
{
dynamic gemini = new Gemini(new {FirstName = "Jane", LastName = "Doe"});
IDictionary<string, object> properties = gemini.HashOfProperties();
Assert.AreEqual(2, properties.Count);
}
public void TestDemo6GeminiRespondsTo()
{
dynamic gemini = new Gemini(new {FirstName = "Jane", LastName = "Doe"});
Assert.IsTrue(gemini.RespondsTo("FirstName"));
Assert.IsFalse(gemini.RespondsTo("IDontExist"));
}
private dynamic EntityFor(dynamic model, dynamic attributes)
{
var entity = new Gemini(attributes);
entity.SetMember(ForeignKey, model.GetMember(PropertyContainingIdValue));
return Repository.Projection(entity);
}
private dynamic EntityFor(dynamic model, dynamic attributes)
{
var entity = new Gemini(attributes);
entity.SetMember(ForeignKey, model.GetMember(Id()));
return(Repository.Projection(entity));
}
public void TestDemo6MembersOnTheFly()
{
dynamic gemini = new Gemini(new { FirstName = "Jane", LastName = "Doe" });
gemini.MiddleInitial = "L";
gemini.SayHello = new Func<string>(() => "Hello");
Assert.AreEqual("Jane", gemini.FirstName);
Assert.AreEqual("L", gemini.MiddleInitial);
Assert.AreEqual("Hello", gemini.SayHello());
}
static DynamicModel()
{
Gemini.Initialized <DynamicModel>(instance =>
{
new Validations(instance);
new Associations(instance);
new Changes(instance);
});
}
public virtual IEnumerable<dynamic> Query(dynamic o)
{
var collection = Collection();
dynamic gemini = new Gemini(o);
var memberName = gemini.Members()[0];
var memberValue = gemini.GetMember(memberName);
var objs = collection.Find(M.Query.EQ(memberName, BsonValue.Create(memberValue))) as MongoCursor<BsonDocument>;
return objs.Select(s => Projection(s));
}
private dynamic GetNamedArgs(object[] args, string[] argNames)
{
var namedArgs = new Gemini();
argNames.Zip(
args.Skip(args.Length - argNames.Length),
(argName, argValue) => new
{
name = argName,
value = argValue
})
.ForEach(arg => namedArgs.SetMember(arg.name, arg.value));
return(namedArgs);
}
public static dynamic ToDynamic(object value)
{
if (value is JValue) return (value as JValue).Value;
if (value is JObject)
{
var gemini = new Gemini();
foreach (var item in (value as JObject)) gemini.SetMember(item.Key, ToDynamic(item.Value));
return gemini;
}
if (value is JArray) return ToArray(value as JArray);
return value;
}
public void it_works()
{
dynamic person = new Gemini(new { FirstName = "Jane" });
Assert.AreEqual("Jane", person.FirstName);
new Changes(person);
Assert.IsFalse(person.HasChanged());
person.FirstName = "Jane2";
Assert.IsTrue(person.HasChanged());
Assert.AreEqual("Jane", person.Changes("FirstName").Original);
Assert.AreEqual("Jane2", person.Changes("FirstName").New);
}
DynamicFunctionWithParam CreateCachedMethodFor(DynamicFunctionWithParam @delegate)
{
var methodName = (@delegate as Delegate).Method.Name;
var newDelegate = new DynamicFunctionWithParam(originalParameters =>
{
dynamic arguments = null;
if (originalParameters is Gemini)
{
arguments = originalParameters.HashOfProperties();
}
else if (IsValueType(originalParameters))
{
arguments = originalParameters;
}
else
{
arguments = new Gemini(originalParameters).HashOfProperties();
}
var cachedValue = null as object;
if (HasSameArgumgents(methodName, arguments, out cachedValue))
{
return(cachedValue);
}
var result = (@delegate as Delegate).Method.Invoke(instance, new[] { originalParameters });
parameterizedFunctions.Add(
new KeyValuePair <MemoizedMethod, object>(
new MemoizedMethod {
Name = methodName, Arguments = arguments
},
result));
return(result);
});
return(newDelegate);
}
public static dynamic RecordToGemini(this IDataReader rdr, Func<dynamic, dynamic> projection)
{
if (projection == null)
{
var e = new Prototype() as IDictionary<string, object>;;
PopluateDynamicDictionary(rdr, e);
return e;
}
else
{
dynamic e = new Gemini();
PopluateDynamicDictionary(rdr, e.Prototype);
return projection(e);
}
}
public dynamic EntityFor(dynamic attributes)
{
var entity = new Gemini(attributes);
return Repository.Projection(entity);
}
dynamic Player(dynamic args)
{
dynamic player = new Gemini(new { IsReady = false });
if (args.PlayerId.ToString() == _.Player1Id) player.IsReady = _.Player1Ready;
else player.IsReady = _.Player2Ready;
return player;
}
public ActionResult Get(int gameId)
{
var game = games.Single(gameId);
dynamic gameResult = new Gemini(game);
gameResult.Player1Squares = game.SquaresFor(game.Player1Id);
gameResult.Player2Squares = game.SquaresFor(game.Player2Id);
gameResult.Player2HitsOnPlayer1 = game.HitsOn(game.Player1Id);
gameResult.Player2MissesOnPlayer1 = game.MissesOn(game.Player1Id);
gameResult.Player1HitsOnPlayer2 = game.HitsOn(game.Player2Id);
gameResult.Player1MissesOnPlayer2 = game.MissesOn(game.Player2Id);
gameResult.Started = game.Started();
gameResult.Loser = game.Loser();
return new DynamicJsonResult(gameResult);
}
public dynamic EntityFor(dynamic attributes)
{
var entity = new Gemini(attributes);
return(Repository.Projection(entity));
}
static Gemini()
{
Gemini.Initialized <Gemini>(d => d.AddRedefinableDelegates());
}
private dynamic EntityFor(DynamicModel model, dynamic attributes)
{
var entity = new Gemini(attributes);
entity.SetMember(ForeignKeyFor(model), model.GetMember(Id()));
return repository.Projection(entity);
}
public static dynamic RecordToGemini(this IDataReader rdr, Func<dynamic, dynamic> projection)
{
dynamic e = new Gemini();
var d = e.Prototype as IDictionary<string, object>;
for (int i = 0; i < rdr.FieldCount; i++)
d.Add(rdr.GetName(i), DBNull.Value.Equals(rdr[i]) ? null : rdr[i]);
return projection(e);
}
