public static InvokeResult Execute(this IRoutine routine, InvokeArgument[] args, IRequest request, IVariableResolver resolver, IGroupResolver group)
{
var invoke = new Invoke(routine.ObjectInfo.FullName, args);
var executeContext = new InvokeContext(invoke, routine, resolver, group, request);
return routine.Execute(executeContext);
}
public double Calc(IVariableResolver resolver)
{
double retval = _expression.Calc(resolver);
if (_sign == Sign.Negative)
retval = retval*-1;
return retval;
}
public ReturnTypeVisitor(IQueryContext queryContext, IVariableResolver variableResolver)
{
this.queryContext = queryContext;
this.variableResolver = variableResolver;
dataType = PrimitiveTypes.Null();
}
public void SetUp()
{
var variableInfo = new VariableInfo("t", PrimitiveTypes.String(), false);
var vrMock = new Mock<IVariableResolver>();
vrMock.Setup(x => x.Resolve(It.Is<ObjectName>(name => name.FullName.Equals("t"))))
.Returns<ObjectName>(name => new Variable(variableInfo));
variableResolver = vrMock.Object;
}
/// <summary>
/// Executes the function given the cintext provided.
/// </summary>
/// <param name="function">The function to execute.</param>
/// <param name="request">The invocation information that was used to resolve
/// the function.</param>
/// <param name="group"></param>
/// <param name="resolver"></param>
/// <param name="query"></param>
/// <returns></returns>
public static DataObject Execute(this IFunction function, Invoke request, IGroupResolver group,
IVariableResolver resolver,
IRequest query)
{
var execContext = new InvokeContext(request, function, resolver, group, query);
var result = function.Execute(execContext);
return result.ReturnValue;
}
public static ExecuteResult Execute(this IRoutine routine, SqlExpression[] args, IQueryContext context, IVariableResolver resolver, IGroupResolver group)
{
var request = new Invoke(routine.FullName, args);
if (context != null &&
!context.UserCanExecuteFunction(request))
throw new InvalidOperationException();
var executeContext = new ExecuteContext(request, routine, resolver, group, context);
return routine.Execute(executeContext);
}
public override double Calc(IVariableResolver resolver)
{
ValidateParameters();
double min = (int)GetParameterValue(1, resolver);
double max = (int)GetParameterValue(2, resolver);
double retval = GetParameterValue(0, new ConstantResolver(min));
for (double i = min + 1; i <= max; i++)
{
retval = Calc(retval, GetParameterValue(0,new ConstantResolver(i)));
}
return AddSign(retval);
}
internal InvokeContext(Invoke invoke, IRoutine routine, IVariableResolver resolver, IGroupResolver group, IRequest request)
{
if (invoke == null)
throw new ArgumentNullException("invoke");
if (routine == null)
throw new ArgumentNullException("routine");
Request = request;
GroupResolver = group;
VariableResolver = resolver;
Invoke = invoke;
Routine = routine;
}
internal ExecuteContext(Invoke invoke, IRoutine routine, IVariableResolver resolver, IGroupResolver group, IQueryContext queryContext)
{
if (invoke == null)
throw new ArgumentNullException("invoke");
if (routine == null)
throw new ArgumentNullException("routine");
QueryContext = queryContext;
GroupResolver = group;
VariableResolver = resolver;
Invoke = invoke;
Routine = routine;
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
if (ob1.IsNull)
{
return(ob1);
}
if (ob2.IsNull)
{
return(ob2);
}
string val = ob1.CastTo(PrimitiveTypes.String()).ToStringValue();
string pattern = ob2.CastTo(PrimitiveTypes.String()).ToStringValue();
// TODO: return DataObject.Boolean(PatternSearch.RegexMatch(context.Context, pattern, val));
throw new NotImplementedException();
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
bool?b1 = ob1.ToBoolean();
bool?b2 = ob2.ToBoolean();
// If either ob1 or ob2 are null
if (!b1.HasValue)
{
return(b2.HasValue && b2.Value.Equals(true) ? DataObject.BooleanTrue : DataObject.BooleanNull);
}
if (!b2.HasValue)
{
return(b1.Value.Equals(true) ? DataObject.BooleanTrue : DataObject.BooleanNull);
}
// If both true.
return(DataObject.Boolean(b1.Equals(true) || b2.Equals(true)));
}
public virtual IScriptingScope CreateScope(IVariableResolver variableResolver)
{
var scope = new JavascriptScope(variableResolver);
var enumerator = this.values.GetEnumerator();
while (enumerator.MoveNext())
{
var entry = enumerator.Current;
scope.SetValue(entry.Key, entry.Value);
}
var enumerator2 = this.clrTypes.GetEnumerator();
while (enumerator2.MoveNext())
{
var entry = enumerator2.Current;
scope.AddClrType(entry.Key, entry.Value);
}
return(scope);
}
/// <summary>
/// /
/// </summary>
/// <param name="templateFile"></param>
/// <param name="dte"></param>
/// <param name="resolver"></param>
public VisualStudioTextTemplateHost(string templateFile, DTE2 dte, IVariableResolver resolver)
{
if (string.IsNullOrEmpty(templateFile))
{
throw new ArgumentNullException("templateFile");
}
if (dte == null)
{
throw new ArgumentNullException("dte");
}
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
_templateFile = templateFile;
_dte = dte;
_resolver = resolver;
var directoryName = Path.GetDirectoryName(templateFile);
Debug.Assert(directoryName != null, "directoryName != null, don't expect templateFile to be a root directory!");
_templateDir = Path.GetFullPath(directoryName);
}
/// <summary>
/// /
/// </summary>
/// <param name="templateFile"></param>
/// <param name="dte"></param>
/// <param name="resolver"></param>
public VisualStudioTextTemplateHost(string templateFile, DTE2 dte, IVariableResolver resolver)
{
if (string.IsNullOrEmpty(templateFile))
{
throw new ArgumentNullException("templateFile");
}
if (dte == null)
{
throw new ArgumentNullException("dte");
}
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
_templateFile = templateFile;
_dte = dte;
_resolver = resolver;
var directoryName = Path.GetDirectoryName(templateFile);
Debug.Assert(directoryName != null, "directoryName != null, don't expect templateFile to be a root directory!");
_templateDir = Path.GetFullPath(directoryName);
}
public static ExecuteResult Execute(this IRoutine routine, SqlExpression[] args, IQueryContext context, IVariableResolver resolver)
{
return Execute(routine, args, context, resolver, null);
}
public EvaluateContext(IRequest request, IVariableResolver variableResolver)
: this(request, variableResolver, null)
{
}
public static DataObject EvaluateToConstant(this SqlExpression expression, IRequest request, IVariableResolver variableResolver)
{
return expression.EvaluateToConstant(new EvaluateContext(request, variableResolver));
}
public BlockExecuteContext(IQuery query, IVariableResolver resolver)
{
Query = query;
VariableResolver = resolver;
}
public void SetFromResolver(IVariableResolver resolver)
{
ObjectName v = Variable;
EvalResult = resolver.Resolve(v);
}
public static InvokeResult Execute(this IRoutine routine, IQuery query, IVariableResolver resolver)
{
return(Execute(routine, query, resolver, null));
}
public static DataType ReturnType(this Expression expression, IVariableResolver resolver, IQueryContext context)
{
var visitor = new Visitor(resolver, context);
return(visitor.FindReturnType(expression));
}
public static InvokeResult Execute(this IRoutine routine, IRequest request, IVariableResolver resolver)
{
return(Execute(routine, request, resolver, null));
}
public virtual IScriptingScope SetVariableResolver(IVariableResolver variableResolver)
{
throw new NotImplementedException();
}
public static InvokeResult Execute(this IRoutine routine, IRequest request, IVariableResolver resolver, IGroupResolver group)
{
return(Execute(routine, new InvokeArgument[0], request, resolver, group));
}
public ReturnTypeVisitor(IRequest query, IVariableResolver variableResolver)
{
this.query = query;
this.variableResolver = variableResolver;
}
public static ExecuteResult Execute(this IRoutine routine, IQueryContext context, IVariableResolver resolver, IGroupResolver group)
{
return Execute(routine, new SqlExpression[0], context, resolver, group);
}
public static SqlType ReturnType(this IFunction function, Invoke request, IRequest query, IVariableResolver resolver)
{
var execContext = new InvokeContext(request, function, resolver, null, query);
return function.ReturnType(execContext);
}
public Visitor(IVariableResolver resolver, IQueryContext context)
{
this.resolver = resolver;
this.context = context;
}
public ScriptParser(string sourceFile, IVariableResolver variableResolver)
{
_parser = new Parser(this, variableResolver, new StreamReader(sourceFile), sourceFile);
}
/// <summary>
/// /
/// </summary>
/// <param name="dte"></param>
/// <param name="templateFileName"></param>
/// <param name="resolver"></param>
/// <returns></returns>
public static Tuple <string, VisualStudioTextTemplateHost> ProcessTemplateInMemory(DTE2 dte, string templateFileName, IVariableResolver resolver)
{
if (dte == null)
{
throw new ArgumentNullException("dte");
}
if (string.IsNullOrEmpty(templateFileName) || !File.Exists(templateFileName))
{
throw new ArgumentException(Resources.Program_ProcessTemplateInMemory_String_is_null_or_empty_or_file_doesn_t_exist_, templateFileName);
}
//// This would be WAY more elegant, but it spawns a confirmation box...
////printfn "Transforming templates..."
////dte.ExecuteCommand("TextTransformation.TransformAllTemplates")
Source.TraceEvent(TraceEventType.Information, 0, Resources.Program_ProcessTemplate_Processing___0_____, templateFileName);
var templateDir = Path.GetDirectoryName(templateFileName);
Debug.Assert(templateDir != null, "templateDir != null, don't expect templateFileName to be a root directory.");
// Setup Environment
var oldDir = Environment.CurrentDirectory;
try
{
Environment.CurrentDirectory = templateDir;
// Setup NamespaceHint in CallContext
var templateFileItem = dte.Solution.FindProjectItem(templateFileName);
var project = templateFileItem.ContainingProject;
var projectDir = Path.GetDirectoryName(project.FullName);
Debug.Assert(projectDir != null, "projectDir != null, don't expect project.FullName to be a root directory.");
string defaultNamespace = project.Properties.Item("DefaultNamespace").Value.ToString();
var templateFileNameUpper = templateFileName.ToUpperInvariant();
var projectDirUpper = projectDir.ToUpperInvariant();
Debug.Assert(templateFileNameUpper.StartsWith(projectDirUpper, StringComparison.Ordinal), "Template file-name is not within the project directory.");
var finalNamespace = defaultNamespace;
if (templateDir.Length != projectDir.Length)
{
var relativeNamespace =
templateDir.Substring(projectDir.Length + 1)
// BUG? Handle all namespace relevant characters
.Replace("\\", ".").Replace("/", ".");
finalNamespace =
string.Format(CultureInfo.InvariantCulture, "{0}.{1}", defaultNamespace, relativeNamespace);
}
using (new LogicalCallContextChange("NamespaceHint", finalNamespace))
{
var host = new VisualStudioTextTemplateHost(templateFileName, dte, resolver);
var engine = new Engine();
var input = File.ReadAllText(templateFileName);
var output = engine.ProcessTemplate(input, host);
return(Tuple.Create(output, host));
}
}
finally
{
Environment.CurrentDirectory = oldDir;
}
}
public static InvokeResult Execute(this IRoutine routine, SqlExpression[] args, IQuery query, IVariableResolver resolver, IGroupResolver group)
{
var request = new Invoke(routine.FullName, args);
if (query != null &&
!query.UserCanExecuteFunction(request))
{
throw new InvalidOperationException();
}
var executeContext = new InvokeContext(request, routine, resolver, group, query);
return(routine.Execute(executeContext));
}
public static SqlType ReturnType(this IFunction function, Invoke request, IRequest query, IVariableResolver resolver)
{
var execContext = new InvokeContext(request, function, resolver, null, query);
return(function.ReturnType(execContext));
}
/// <summary>
/// /
/// </summary>
/// <param name="dte"></param>
/// <param name="templateFileName"></param>
/// <param name="resolver"></param>
/// <returns></returns>
public static Tuple<string, VisualStudioTextTemplateHost> ProcessTemplateInMemory(DTE2 dte, string templateFileName, IVariableResolver resolver)
{
if (dte == null)
{
throw new ArgumentNullException("dte");
}
if (string.IsNullOrEmpty(templateFileName) || !File.Exists(templateFileName))
{
throw new ArgumentException(Resources.Program_ProcessTemplateInMemory_String_is_null_or_empty_or_file_doesn_t_exist_, templateFileName);
}
//// This would be WAY more elegant, but it spawns a confirmation box...
////printfn "Transforming templates..."
////dte.ExecuteCommand("TextTransformation.TransformAllTemplates")
Source.TraceEvent(TraceEventType.Information, 0, Resources.Program_ProcessTemplate_Processing___0_____, templateFileName);
var templateDir = Path.GetDirectoryName(templateFileName);
Debug.Assert(templateDir != null, "templateDir != null, don't expect templateFileName to be a root directory.");
// Setup Environment
var oldDir = Environment.CurrentDirectory;
try
{
Environment.CurrentDirectory = templateDir;
// Setup NamespaceHint in CallContext
var templateFileItem = dte.Solution.FindProjectItem(templateFileName);
var project = templateFileItem.ContainingProject;
var projectDir = Path.GetDirectoryName(project.FullName);
Debug.Assert(projectDir != null, "projectDir != null, don't expect project.FullName to be a root directory.");
string defaultNamespace = project.Properties.Item("DefaultNamespace").Value.ToString();
var templateFileNameUpper = templateFileName.ToUpperInvariant();
var projectDirUpper = projectDir.ToUpperInvariant();
Debug.Assert(templateFileNameUpper.StartsWith(projectDirUpper, StringComparison.Ordinal), "Template file-name is not within the project directory.");
var finalNamespace = defaultNamespace;
if (templateDir.Length != projectDir.Length)
{
var relativeNamespace =
templateDir.Substring(projectDir.Length + 1)
// BUG? Handle all namespace relevant characters
.Replace("\\", ".").Replace("/", ".");
finalNamespace =
string.Format(CultureInfo.InvariantCulture, "{0}.{1}", defaultNamespace, relativeNamespace);
}
using (new LogicalCallContextChange("NamespaceHint", finalNamespace))
{
var host = new VisualStudioTextTemplateHost(templateFileName, dte, resolver);
var engine = new Engine();
var input = File.ReadAllText(templateFileName);
var output = engine.ProcessTemplate(input, host);
return Tuple.Create(output, host);
}
}
finally
{
Environment.CurrentDirectory = oldDir;
}
}
public void SetUp()
{
this.variableResolver = Substitute.For <IVariableResolver>();
this.typeTranslator = Substitute.For <ITypeTranslator>();
this.valueResolver = new ValueResolver(this.variableResolver, this.typeTranslator);
}
/// <summary>
/// Gets the return type of the expression when evaluated.
/// </summary>
/// <param name="expression">The expression to check.</param>
/// <param name="query">The query context used to evaluate the return type
/// of the expression.</param>
/// <param name="variableResolver">The object used to resolve variable references in the expression tree.</param>
/// <returns>
/// Returns the <see cref="SqlType"/> that an evaluation of the expression
/// would return, or <c>null</c> if the final result of the evaluation has
/// no return type.
/// </returns>
public static SqlType ReturnType(this SqlExpression expression, IRequest query, IVariableResolver variableResolver)
{
var visitor = new ReturnTypeVisitor(query, variableResolver);
return visitor.GetType(expression);
}
public double Calc(IVariableResolver variableValue)
{
if (_sign == Sign.Positive)
return _coeficient*Math.Pow(variableValue.Resolve(Variable), _exponent);
return _coeficient * Math.Pow(variableValue.Resolve(Variable), _exponent) * -1;
}
public InvokeResult Execute(IRequest query, IVariableResolver resolver)
{
return(Execute(query, resolver, null));
}
public InvokeResult Execute(IRequest query, IVariableResolver resolver)
{
return Execute(query, resolver, null);
}
public EvaluateContext(IRequest request, IVariableResolver variableResolver, IGroupResolver groupResolver)
{
GroupResolver = groupResolver;
VariableResolver = variableResolver;
Request = request;
}
public InvokeResult Execute(IRequest query, IVariableResolver resolver, IGroupResolver group)
{
var routine = ResolveRoutine(query);
var executeContext = new InvokeContext(this, routine, resolver, group, query);
return routine.Execute(executeContext);
}
public static ExecuteResult Execute(this IRoutine routine, IQueryContext context, IVariableResolver resolver)
{
return Execute(routine, context, resolver, null);
}
public HackSymbolResolver(ILabelResolver hackLabelResolver, IVariableResolver hackVariableResolver)
{
_hackLabelResolver = hackLabelResolver;
_hackVariableResolver = hackVariableResolver;
}
public SqlExpression Evaluate(IRequest context, IVariableResolver variables, IGroupResolver group)
{
return(Evaluate(new EvaluateContext(context, variables, group)));
}
public EvaluateContext(IQueryContext queryContext, IVariableResolver variableResolver, IGroupResolver groupResolver)
{
GroupResolver = groupResolver;
VariableResolver = variableResolver;
QueryContext = queryContext;
}
public SqlExpression Evaluate(IRequest context, IVariableResolver variables)
{
return(Evaluate(context, variables, null));
}
public static Field EvaluateToConstant(this SqlExpression expression, IRequest request, IVariableResolver variableResolver)
{
return(expression.EvaluateToConstant(new EvaluateContext(request, variableResolver)));
}
public Field Evaluate(IVariableResolver resolver, IRequest context)
{
var variable = resolver.Resolve(Name);
Value = variable.Evaluate(context);
return Value;
}
public static InvokeResult Execute(this IRoutine routine, InvokeArgument[] args, IRequest query, IVariableResolver resolver)
{
return(Execute(routine, args, query, resolver, null));
}
public static InvokeResult Execute(this IRoutine routine, SqlExpression[] args, IQuery query, IVariableResolver resolver)
{
return(Execute(routine, args, query, resolver, null));
}
public HackSymbolResolver(ILabelResolver hackLabelResolver, IVariableResolver hackVariableResolver)
{
_hackLabelResolver = hackLabelResolver;
_hackVariableResolver = hackVariableResolver;
}
public static InvokeResult Execute(this IRoutine routine, IQuery query, IVariableResolver resolver, IGroupResolver group)
{
return(Execute(routine, new SqlExpression[0], query, resolver, group));
}
public override double Calc(IVariableResolver resolver)
{
return AddSign(Math.PI);
}
public EvaluateContext(IRequest request, IVariableResolver variableResolver)
: this(request, variableResolver, null)
{
}
public static InvokeResult Execute(this IRoutine routine, InvokeArgument[] args, IRequest request, IVariableResolver resolver, IGroupResolver group)
{
var invoke = new Invoke(routine.ObjectInfo.FullName, args);
var executeContext = new InvokeContext(invoke, routine, resolver, group, request);
return(routine.Execute(executeContext));
}
public EvaluateContext(IQueryContext queryContext, IVariableResolver variableResolver)
: this(queryContext, variableResolver, null)
{
}
public EvaluateContext(IRequest request, IVariableResolver variableResolver, IGroupResolver groupResolver)
{
GroupResolver = groupResolver;
VariableResolver = variableResolver;
Request = request;
}
public override double Calc(IVariableResolver resolver)
{
ValidateParameters();
return AddSign(Math.Tan(GetParameterValue(0, resolver)));
}
public DataObject Evaluate(IVariableResolver resolver)
{
Value = resolver.Resolve(Name);
return Value;
}
/// <summary>
/// Gets the return type of the expression when evaluated.
/// </summary>
/// <param name="expression">The expression to check.</param>
/// <param name="query">The query context used to evaluate the return type
/// of the expression.</param>
/// <param name="variableResolver">The object used to resolve variable references in the expression tree.</param>
/// <returns>
/// Returns the <see cref="SqlType"/> that an evaluation of the expression
/// would return, or <c>null</c> if the final result of the evaluation has
/// no return type.
/// </returns>
public static SqlType ReturnType(this SqlExpression expression, IRequest query, IVariableResolver variableResolver)
{
var visitor = new ReturnTypeVisitor(query, variableResolver);
return(visitor.GetType(expression));
}
public DataObject Evaluate(IVariableResolver resolver)
{
Value = resolver.Resolve(Name);
return(Value);
}
