/// <summary> /// Internal function to hide looking at all function objects. /// </summary> /// <param name="c"></param> /// <param name="arguments"></param> /// <param name="functionName"></param> /// <returns></returns> private Func <object> FindFunction(IScopeContext c, IEnumerable <IExpression> arguments, string functionName) { return(ExtensibilityControl.Get().FunctionFinders .Select(ff => ff.FindFunction(c, arguments, functionName)) .Where(f => f != null) .FirstOrDefault()); }
public void MakeSureInitIsCalled() { MyFunc.WasCalled = false; var rootContext = new RootContext(); ExtensibilityControl.Get().InitializeFunctionObjects(rootContext); Assert.IsTrue(MyFunc.WasCalled, "Initialize method was not called"); }
/// <summary> /// Returns a list of all functions we can find that have the proper name. /// </summary> /// <param name="FunctionName"></param> /// <returns></returns> private static IEnumerable <MethodInfo> ListOfFuncsWithName(string fname) { var funcs = (from fo in ExtensibilityControl.Get().FunctionObjects from m in fo.GetType().GetMethods(BindingFlags.Public | BindingFlags.Static) where m.Name == fname select m).ToArray(); return(funcs); }
/// <summary> /// Find a method in the code, Account for use of C# reserved words by added "Reserved" onto the end of the method /// we are trying to find. /// </summary> /// <param name="methodName"></param> /// <param name="args"></param> /// <returns></returns> /// <remarks>Default arguments make this a little more difficult to deal with</remarks> private static MethodInfo[] FindMethodForArgs(string methodName, object[] args) { // Look for all functions that match the name we want. var argListTypes = args.Select(a => a.GetType()).ToArray(); string methodNameFixed = methodName.FixUpReserved(); var funcs = (from fo in ExtensibilityControl.Get().FunctionObjects from m in fo.GetType().GetMethods() where m.Name == methodNameFixed where m.IsStatic let newm = m.ArgumentListMatches(argListTypes, fo.GetType()) where newm != null select newm).Distinct().ToArray(); return(funcs); }
/// <summary> /// Evaluate the method call. Use a list of evaluators to try to accomplish the call. /// </summary> /// <param name="c"></param> /// <returns></returns> public object Evaluate(IScopeContext c) { // All functions and the source object must evaluate correctly. Further, since we want to do the // evaluate only once, we do it here, at the top. var obj = ObjectExpression.Evaluate(c); var args = FunctionCall.Arguments.Select(a => a.Evaluate(c)).ToArray(); // Find the first evaluator that can figure out what this is. var goodEval = ExtensibilityControl.Get().MethodEvaluators .Select(e => e.Evaluate(c, obj, FunctionCall.FunctionName, args)).Where(r => r.Item1).FirstOrDefault(); if (goodEval != null) { return(c.ExecutionContext.ExecutePostCallHook(FunctionCall.FunctionName, obj, goodEval.Item2)); } throw new InvalidOperationException(string.Format("Don't know how to call the function {0} on the object {1} of type {2}.", FunctionCall.ToString(), ObjectExpression.ToString(), obj.GetType().Name)); }