public async Task <object> Invoke(object context)
{
var evaluationContext = new ContextFrame {
Scope = context, Step = this,
};
// check the existence of the object
var check = false;
try
{
await Interpolate(Name);
check = true;
}
catch (Exception)
{
}
if (!check)
{
// create list if not exist
var List = new List <dynamic>();
await Interpolator.AssignValueOnDynamic(context, Name, List);
}
var expressionValue = await Interpolate(Expression);
var result = await AppendValueOnDynamic(Name, expressionValue);
Task <object> Interpolate(string expression) => Interpolator.InterpolateExpression(expression, evaluationContext);
Task <object> AppendValueOnDynamic(string name, dynamic value) => Interpolator.AppendValueOnDynamic(context, name, value);
return(result);
}
public async Task <object> Invoke(object context)
{
var contextFrame = new ContextFrame {
Scope = context, Step = this
};
var url = (string) await interpolate(UrlExpression);
var console = (bool) await interpolate(ConsoleWrite);
url = HttpUtility.HtmlDecode(url);
var isJSON = (bool) await interpolate(IsJSONExpression);
var client = new HttpClient();
if (console)
{
Console.WriteLine($"Request with HTTP GET from: ${url}... hold your horses.");
}
var response = await client.GetAsync(url);
var resultString = await response.Content.ReadAsStringAsync();
if (!isJSON)
{
return(resultString);
}
return(JsonConvert.DeserializeObject <dynamic>(resultString));
Task <object> interpolate(string expression) => Interpolator.InterpolateExpression(expression, contextFrame);
}
public async Task <object> Invoke(object context)
{
dynamic ctx = context;
foreach (var item in Items)
{
var itemResult = await item.Invoke(context);
if (item.Definition.ContainsKey("_resultTo"))
{
var contextFrame = new ContextFrame {
Scope = context, Step = this
};
var key = item.Definition["_resultTo"];
await Interpolator.AssignValueOnDynamic(context, key, itemResult);
}
}
return(await Task.FromResult((object)true));
}
public async Task <object> Invoke(object context)
{
// get html text
var contextFrame = new ContextFrame {
Scope = context, Step = this
};
var htmlString = (string) await interpolate(HtmlExpression);
// parse html to document object
var htmlDoc = new HtmlDocument();
htmlDoc.LoadHtml(htmlString);
htmlDoc.OptionAutoCloseOnEnd = true;
return(htmlDoc);
Task <object> interpolate(string expression) => Interpolator.InterpolateExpression(expression, contextFrame);
}
public async Task <object> Invoke(object context)
{
// get html text
var contextFrame = new ContextFrame {
Scope = context, Step = this
};
var htmlDoc = (HtmlDocument) await interpolate(DocumentNode);
//var selector = (string)await interpolate(Selector);
// run selector
HtmlNodeCollection nodes = htmlDoc.DocumentNode
.SelectNodes(Selector);
// run ndoe expression
//var nodeContextFrame = new NodeContextFrame { NodeList = nodes };
//return await Interpolator.InterpolateExpression(NodeExpression, nodeContextFrame);
return(nodes);
Task <object> interpolate(string expression) => Interpolator.InterpolateExpression(expression, contextFrame);
}
public static Dictionary <int, Dictionary <ISyntaxRegion, byte> > Scan(DModule ast, ResolutionContext ctxt)
{
if (ast == null)
{
return(new Dictionary <int, Dictionary <ISyntaxRegion, byte> >());
}
var typeRefFinder = new TypeReferenceFinder(ctxt);
ContextFrame backupFrame = null;
if (ctxt.ScopedBlock == ast)
{
backupFrame = ctxt.Pop();
}
/*
* if (ctxt.CurrentContext == null)
* {
* ctxt.Push(backupFrame);
* backupFrame = null;
* }*/
//typeRefFinder.ast = ast;
// Enum all identifiers
ast.Accept(typeRefFinder);
if (backupFrame != null)
{
ctxt.Push(backupFrame);
}
// Crawl through all remaining expressions by evaluating their types and check if they're actual type references.
/*typeRefFinder.queueCount = typeRefFinder.q.Count;
* typeRefFinder.ResolveAllIdentifiers();
*/
return(typeRefFinder.Matches);
}
public async Task <object> Invoke(object context)
{
dynamic ctx = context;
var contextFrame = new ContextFrame {
Scope = context, Step = this
};
var items = await Interpolator.InterpolateExpression(InExpression, contextFrame);
var varName = VarName ?? "Scope.Item";
if (items is IEnumerable itemsCollection)
{
foreach (var item in itemsCollection)
{
await Interpolator.AssignValueOnDynamic(context, varName, item);
await LoopTask.Invoke(context);
}
}
return(true);
}
public async Task <object> Invoke(object context)
{
var evaluationContext = new ContextFrame {
Scope = context, Step = this,
};
if (!(Expression is string))
{
// get result object
//var resultObject = Interpolate(Name).Result;
//var resultList = new List<dynamic>();
try
{
var dictionary = (IDictionary <string, dynamic>)Expression;
await AssignValueOnDynamic(Name, new System.Dynamic.ExpandoObject());
//context.Result = new System.Dynamic.ExpandoObject();
//var iss = new System.Dynamic.ExpandoObject();
foreach (var expressionItem in dictionary)
{
if (expressionItem.Value is string)
{
await AssignValue(expressionItem.Value, Name + "." + expressionItem.Key);
}
else if (expressionItem.Value is object)
{
try
{
var dc = (IDictionary <string, dynamic>)expressionItem.Value;
dynamic selector;
dynamic expression;
if (dc.TryGetValue("selector", out selector))
{
var definition = new Dictionary <string, dynamic>()
{
{ "from", FromNode }, { "selector", selector }
};
SelectNodes.InitializeFromJson(definition);
var result = SelectNodes.Invoke(context).Result;
if (dc.TryGetValue("expression", out expression))
{
var expressionValue = "";
if (result != null)
{
var ResultContext = new Marshal()
{
Result = result
};
expressionValue = await Interpolator.InterpolateExpression(expression, ResultContext);
}
await AssignValueOnDynamic(Name + "." + expressionItem.Key, expressionValue);
}
}
}
catch (Exception)
{
throw;
}
}
}
}
catch (Exception)
{
throw;
}
}
else
{
await AssignValue(Expression, Name);
}
async Task <object> AssignValue(string expression, string name)
{
var expressionValue = await Interpolate(expression);
return(await AssignValueOnDynamic(name, expressionValue));
}
Task <object> Interpolate(string expression) => Interpolator.InterpolateExpression(expression, evaluationContext);
Task <object> AssignValueOnDynamic(string name, dynamic expressionValue) => Interpolator.AssignValueOnDynamic(context, name, expressionValue);
return(Name);
}
public bool TryStepForward()
{
if (_failedForward || _endOfFile)
return false;
if (_input.Index + _lookAheadPosition >= _input.Count)
{
_endOfFile = true;
return false;
}
IToken token = _input.LT(-1 - _lookBehindPosition);
if (token == null)
{
_endOfFile = true;
return false;
}
int symbol = token.Type;
int symbolPosition = token.TokenIndex;
Stopwatch updateTimer = Stopwatch.StartNew();
if (_lookAheadPosition == 0 && _lookBehindPosition == 0 && _contexts.Count == 0)
{
HashSet<InterpretTrace> initialContexts = new HashSet<InterpretTrace>(EqualityComparer<InterpretTrace>.Default);
/* create our initial set of states as the ones at the target end of a match transition
* that contains 'symbol' in the match set.
*/
List<Transition> transitions = new List<Transition>(_network.Transitions.Where(i => i.MatchesSymbol(symbol)));
foreach (var transition in transitions)
{
if (ExcludedStartRules.Contains(Network.StateRules[transition.SourceState.Id]))
continue;
if (ExcludedStartRules.Contains(Network.StateRules[transition.TargetState.Id]))
continue;
ContextFrame startContext = new ContextFrame(transition.SourceState, null, null, this);
ContextFrame endContext = new ContextFrame(transition.SourceState, null, null, this);
initialContexts.Add(new InterpretTrace(startContext, endContext));
}
_contexts.AddRange(initialContexts);
}
List<InterpretTrace> existing = new List<InterpretTrace>(_contexts);
_contexts.Clear();
SortedSet<int> states = new SortedSet<int>();
HashSet<InterpretTrace> contexts = new HashSet<InterpretTrace>(EqualityComparer<InterpretTrace>.Default);
#if false
HashSet<ContextFrame> existingUnique = new HashSet<ContextFrame>(existing.Select(i => i.StartContext), EqualityComparer<ContextFrame>.Default);
Contract.Assert(existingUnique.Count == existing.Count);
#endif
foreach (var context in existing)
{
states.Add(context.EndContext.State.Id);
StepForward(contexts, states, context, symbol, symbolPosition, PreventContextType.None);
states.Clear();
}
bool success = false;
if (contexts.Count > 0)
{
_contexts.AddRange(contexts);
if (TrackBoundedContexts)
_boundedEndContexts.UnionWith(_contexts.Where(i => i.BoundedEnd));
success = true;
}
else
{
_contexts.AddRange(existing);
}
long nfaUpdateTime = updateTimer.ElapsedMilliseconds;
if (success)
_lookAheadPosition++;
if (!success)
_failedForward = true;
return success;
}
public bool TryStepBackward()
{
if (_failedBackward || _beginningOfFile)
return false;
if (_input.Index - _lookBehindPosition <= 0)
{
_beginningOfFile = true;
return false;
}
IToken token = _input.LT(-1 - _lookBehindPosition);
if (token == null)
{
_beginningOfFile = true;
return false;
}
int symbol = token.Type;
int symbolPosition = token.TokenIndex;
/*
* Update the non-deterministic trace
*/
Stopwatch updateTimer = Stopwatch.StartNew();
if (_lookAheadPosition == 0 && _lookBehindPosition == 0 && _contexts.Count == 0)
{
HashSet<InterpretTrace> initialContexts = new HashSet<InterpretTrace>(EqualityComparer<InterpretTrace>.Default);
/* create our initial set of states as the ones at the target end of a match transition
* that contains 'symbol' in the match set.
*/
List<Transition> transitions = new List<Transition>(_network.Transitions.Where(i => i.MatchesSymbol(symbol)));
foreach (var transition in transitions)
{
if (ExcludedStartRules.Contains(Network.StateRules[transition.SourceState.Id]))
continue;
if (ExcludedStartRules.Contains(Network.StateRules[transition.TargetState.Id]))
continue;
ContextFrame startContext = new ContextFrame(transition.TargetState, null, null, this);
ContextFrame endContext = new ContextFrame(transition.TargetState, null, null, this);
initialContexts.Add(new InterpretTrace(startContext, endContext));
}
_contexts.AddRange(initialContexts);
#if DFA
DeterministicState deterministicState = new DeterministicState(_contexts.Select(i => i.StartContext));
_deterministicTrace = new DeterministicTrace(deterministicState, deterministicState);
#endif
}
List<InterpretTrace> existing = new List<InterpretTrace>(_contexts);
_contexts.Clear();
SortedSet<int> states = new SortedSet<int>();
HashSet<InterpretTrace> contexts = new HashSet<InterpretTrace>(EqualityComparer<InterpretTrace>.Default);
#if false
HashSet<ContextFrame> existingUnique = new HashSet<ContextFrame>(existing.Select(i => i.StartContext), EqualityComparer<ContextFrame>.Default);
Contract.Assert(existingUnique.Count == existing.Count);
#endif
foreach (var context in existing)
{
states.Add(context.StartContext.State.Id);
StepBackward(contexts, states, context, symbol, symbolPosition, PreventContextType.None);
states.Clear();
}
bool success = false;
if (contexts.Count > 0)
{
_contexts.AddRange(contexts);
if (TrackBoundedContexts)
_boundedStartContexts.UnionWith(_contexts.Where(i => i.BoundedStart));
success = true;
}
else
{
_contexts.AddRange(existing);
}
long nfaUpdateTime = updateTimer.ElapsedMilliseconds;
#if DFA
/*
* Update the deterministic trace
*/
updateTimer.Restart();
DeterministicTransition deterministicTransition = _deterministicTrace.StartState.IncomingTransitions.SingleOrDefault(i => i.MatchSet.Contains(symbol));
if (deterministicTransition == null)
{
DeterministicState sourceState = new DeterministicState(contexts.Select(i => i.StartContext));
DeterministicState targetState = _deterministicTrace.StartState;
deterministicTransition = targetState.IncomingTransitions.SingleOrDefault(i => i.SourceState.Equals(sourceState));
if (deterministicTransition == null)
{
deterministicTransition = new DeterministicTransition(targetState);
sourceState.AddTransition(deterministicTransition);
}
deterministicTransition.MatchSet.Add(symbol);
}
IEnumerable<DeterministicTraceTransition> deterministicTransitions = Enumerable.Repeat(new DeterministicTraceTransition(deterministicTransition, symbol, symbolPosition, this), 1);
deterministicTransitions = deterministicTransitions.Concat(_deterministicTrace.Transitions);
_deterministicTrace = new DeterministicTrace(deterministicTransition.SourceState, _deterministicTrace.EndState, deterministicTransitions);
long dfaUpdateTime = updateTimer.ElapsedMilliseconds;
#endif
if (success)
_lookBehindPosition++;
if (!success)
_failedBackward = true;
return success;
}
