private ISet <string> GetVariables(Expression expression)
{
var variableCollector = new DependencyCollector();
variableCollector.Collect(expression);
return(variableCollector.Dependencies);
}
internal async Task CompareBaselineAndRestoreAsync(ModuleModel model, IPythonModule m)
{
//var json = ToJson(model);
//Baseline.CompareToFile(BaselineFileName, json);
// In real case dependency analysis will restore model dependencies.
// Here we don't go through the dependency analysis so we have to
// manually restore dependent modules.
var dc = new DependencyCollector(m);
dc.AddImports(model.Imports);
dc.AddFromImports(model.FromImports);
foreach (var dep in dc.Dependencies)
{
m.Interpreter.ModuleResolution.GetOrLoadModule(dep.Name);
}
var dcs = new DependencyCollector(m, true);
dcs.AddImports(model.StubImports);
dcs.AddFromImports(model.StubFromImports);
foreach (var dep in dcs.Dependencies)
{
m.Interpreter.TypeshedResolution.GetOrLoadModule(dep.Name);
}
var analyzer = Services.GetService <IPythonAnalyzer>();
await analyzer.WaitForCompleteAnalysisAsync();
using (var dbModule = CreateDbModule(model, m.FilePath)) {
dbModule.Should().HaveSameMembersAs(m);
}
}
public static void Calculate()
{
dependencyList = Database.objects.CreateMapping <DependencyList[]>();
reverseDependencies = Database.objects.CreateMapping <List <FactorioId> >();
foreach (var obj in Database.objects.all)
{
reverseDependencies[obj] = new List <FactorioId>();
}
var collector = new DependencyCollector();
var temp = new List <FactorioObject>();
foreach (var obj in Database.objects.all)
{
obj.GetDependencies(collector, temp);
var packed = collector.Pack();
dependencyList[obj] = packed;
foreach (var group in packed)
{
foreach (var req in group.elements)
{
if (!reverseDependencies[req].Contains(obj.id))
{
reverseDependencies[req].Add(obj.id);
}
}
}
}
}
private ISet <string> GetVariables(Statement statement)
{
var variableCollector = new DependencyCollector();
variableCollector.Collect(statement);
return(variableCollector.Dependencies);
}
public static void AddFromImports(this DependencyCollector dc, IEnumerable <FromImportModel> imports)
{
foreach (var imp in imports)
{
dc.AddFromImport(imp.RootNames, imp.MemberNames, imp.DotCount, imp.ForceAbsolute);
}
}
public DependencyProvider(IPythonModule module, ModuleModel model)
{
var dc = new DependencyCollector(module);
dc.AddImports(model.Imports);
dc.AddFromImports(model.FromImports);
_dependencies = dc.Dependencies;
}
public DependencyCollectorForm(DependencyCollector depColl)
{
InitializeComponent();
this.DependencyCollector = depColl;
this.depComTextBox.Text = this.DependencyCollector.DependencyCombination;
this.depFcnCheckBox.Checked = false;
this.depFcnRichTextBox.Enabled = false;
}
public void ShouldCollectNotifiableRootAsDependency()
{
var source = new Source();
var expression = (Expression <Func <string> >)(() => source.Name);
var root = new DependencyCollector(expression).Dependencies.Single();
Assert.AreEqual("Name", root.PropertyName);
Assert.IsEmpty(root.SubDependencies);
}
public void ShouldCollectLinksAsDependenciesIfNotifiable()
{
var source = new Source();
var expression = (Expression <Func <string> >)(() => source.Inner.Name);
var root = new DependencyCollector(expression).Dependencies.Single();
Assert.AreEqual("Inner", root.PropertyName);
var subDependency = root.SubDependencies.Single();
Assert.AreEqual("Name", subDependency.PropertyName);
}
public static void AddImports(this DependencyCollector dc, IEnumerable <ImportModel> imports)
{
foreach (var imp in imports)
{
foreach (var dottedName in imp.ModuleNames)
{
var importNames = ImmutableArray <string> .Empty;
foreach (var part in dottedName.NameParts)
{
importNames = importNames.Add(part);
dc.AddImport(importNames, imp.ForceAbsolute);
}
}
}
}
public ComputedProperty(Expression <Func <TObj, TResult> > expression)
{
_func = DependencyCollector.Create(expression);
}
