public void transient_cache_by_default_is_a_nullo() { var plugins = new PluginGraph(); var pipeline = new RootPipelineGraph(plugins); pipeline.Transients.ShouldBeOfType<NulloTransientCache>(); }
private void validateInstance(IDiagnosticInstance instance, PluginFamily family, PluginGraph graph) { if (!instance.CanBePartOfPluginFamily(family)) { graph.Log.RegisterError(104, instance.CreateToken(), family.PluginType); } }
public GraphBuilder(PluginGraph pluginGraph) { _pluginGraph = pluginGraph; _assemblyScanner = new AssemblyScanner(); _instanceReader = new XmlInstanceReader(_pluginGraph.Log, new Registry()); }
public void Read_in_a_class_with_primitive_arrays() { string xml = @" <Instance> <numbers Values='1,2,3'/> <strings Values='1,2,3'/> </Instance> "; XmlElement element = DataMother.BuildDocument(xml).DocumentElement; element.SetAttribute("PluggedType", typeof (ClassWithStringAndIntArray).AssemblyQualifiedName); var memento = new XmlAttributeInstanceMemento(element); var graph = new PluginGraph(); Instance instance = memento.ReadInstance(typeof (ClassWithStringAndIntArray)); Assert.Fail("NWO"); // var theObject = (ClassWithStringAndIntArray) instance.Build(typeof (ClassWithStringAndIntArray), // BuildSession.ForPluginGraph(graph)); // // theObject.Numbers.ShouldEqual(new[] {1, 2, 3}); // theObject.Strings.ShouldEqual(new[] {"1", "2", "3"}); // // Debug.WriteLine(theObject.GetType().AssemblyQualifiedName); }
public void AssertErrors_throws_StructureMapConfigurationException_if_there_is_an_error() { var graph = new PluginGraph(); graph.Log.RegisterError(400, new ApplicationException("Bad!")); graph.Log.AssertFailures(); }
private void addCloseGenericPolicyTo(PluginGraph graph) { var policy = new CloseGenericFamilyPolicy(graph); graph.AddFamilyPolicy(policy); graph.Profiles.Each(addCloseGenericPolicyTo); }
private static void ThrowIfMarkerInterfaceIsRegistered(PluginGraph graph) { if (graph.HasFamily<IMarkerInterface>()) { throw new InvalidOperationException("Populate should only be called once per container."); } }
public PluginFamily(Type pluginType, PluginGraph parent) { _parent = parent; _pluginType = pluginType; PluginFamilyAttribute.ConfigureFamily(this); }
public void Seal_does_not_throw_an_exception_if_there_are_no_errors() { var graph = new PluginGraph(); Assert.AreEqual(0, graph.Log.ErrorCount); graph.Seal(); }
public void transient_cache_of_nested_pipeline_graph_is_a_stateful_cache() { var plugins = new PluginGraph(); var pipeline = PipelineGraph.BuildRoot(plugins); pipeline.ToNestedGraph().Transients.ShouldBeOfType<LifecycleObjectCache>(); }
public PluginGraphBuilder(ConfigurationParser[] parsers, Registry[] registries, GraphLog log) { _parsers = parsers; _registries = registries; _graph = new PluginGraph(); _graph.Log = log; }
public void Apply(PluginGraph graph) { var registry = new Registry(); _interfaces.Each(@interface => { var expression = registry.For(@interface); ConfigureFamily(expression); var exactMatches = _concretions.Where(x => x.CanBeCastTo(@interface)).ToArray(); if (exactMatches.Length == 1) { expression.Use(exactMatches.Single()); } else { exactMatches.Each(type => expression.Add(type)); } if ([email protected]()) { addConcretionsThatCouldBeClosed(@interface, expression); } }); _concretions.Each(t => graph.ConnectedConcretions.Fill(t)); registry.As<IPluginGraphConfiguration>().Configure(graph); }
public IPipelineGraph NewChild() { var childGraph = new PluginGraph(); var instances = new ComplexInstanceGraph(_root, childGraph, ContainerRole.ProfileOrChild); return new PipelineGraph(childGraph, instances, _root, _root.Singletons, _root.Transients); }
public void Process(Type type, PluginGraph graph) { if (!IsConcrete(type)) return; if (type.Name.EndsWith("Actor") && type.Implements<AsyncHttpActor>()) graph.AddType(typeof(AsyncHttpActor), type); }
public void build_root_for_tracked_transients() { var pluginGraph = new PluginGraph { TransientTracking = TransientTracking.ExplicitReleaseMode }; var graph = PipelineGraph.BuildRoot(pluginGraph); graph.Transients.ShouldBeOfType<TrackingTransientCache>(); }
public void build_root_for_default_tracking_style() { var pluginGraph = new PluginGraph {TransientTracking = TransientTracking.DefaultNotTrackedAtRoot}; var graph = PipelineGraph.BuildRoot(pluginGraph); graph.Transients.ShouldBeOfType<NulloTransientCache>(); }
public void Process(Type type, PluginGraph graph) { Type interfaceType = type.FindInterfaceThatCloses(typeof(IHbmWriter<>)); if (interfaceType != null) { graph.AddType(interfaceType, type); } }
// ASP.NET expects registered services to be considered when selecting a ctor, SM doesn't by default. public ConstructorInfo Find(Type pluggedType, DependencyCollection dependencies, PluginGraph graph) => pluggedType.GetTypeInfo() .DeclaredConstructors .Select(ctor => new { Constructor = ctor, Parameters = ctor.GetParameters() }) .Where(x => x.Parameters.All(param => graph.HasFamily(param.ParameterType))) .OrderByDescending(x => x.Parameters.Length) .Select(x => x.Constructor) .FirstOrDefault();
public ConstructorInfo Find(Type pluggedType, DependencyCollection dependencies, PluginGraph graph) { // if this rule does not apply to the pluggedType, // just return null to denote "not applicable" if (!pluggedType.CanBeCastTo<BaseThing>()) return null; return pluggedType.GetConstructor(new[] {typeof (IWidget)}); }
public RootPipelineGraph(PluginGraph pluginGraph) { _pluginGraph = pluginGraph; _transientCache = new NulloTransientCache(); _profiles = new Cache<string, IPipelineGraph>( name => new ComplexPipelineGraph(this, _pluginGraph.Profile(name), new NulloTransientCache())); }
public void default_lifecycle_not_set_on_any_level() { var graph = new PluginGraph(); var pipeline = PipelineGraph.BuildRoot(graph).Profiles.For("Red"); pipeline.Instances.DefaultLifecycleFor(typeof(IGateway)) .ShouldBeNull(); }
public ConstructorInfo Find(Type pluggedType, DependencyCollection dependencies, PluginGraph graph) { return pluggedType .GetConstructors() .Where(x => !HasMissingPrimitives(x, dependencies)) .OrderByDescending(x => x.GetParameters().Count()) .FirstOrDefault(); }
public void SetUp() { graph = new PluginGraph(); pipeline = new PipelineGraph(graph); library = new InterceptorLibrary(); builder = new ObjectBuilder(pipeline, library); }
public void singleton_is_just_the_plugin_graph_singletons() { var plugins = new PluginGraph(); plugins.SingletonCache.ShouldNotBeNull(); var pipeline = new RootPipelineGraph(plugins); pipeline.Singletons.ShouldBeTheSameAs(plugins.SingletonCache); }
public void default_lifecycle_is_explicitly_set() { var graph = new PluginGraph(); graph.Families[typeof(IGateway)].SetLifecycleTo<SingletonLifecycle>(); var root = new RootInstanceGraph(graph); root.DefaultLifecycleFor(typeof(IGateway)).ShouldBeOfType<SingletonLifecycle>(); }
public void default_lifecycle_is_null_if_family_has_no_lifecycle() { var graph = new PluginGraph(); graph.Families[typeof (IGateway)].SetDefault(new SmartInstance<StubbedGateway>()); var root = new RootInstanceGraph(graph); root.DefaultLifecycleFor(typeof(IGateway)).ShouldBeNull(); }
public InstanceMementoPropertyReader(ConfiguredInstance instance, InstanceMemento memento, PluginGraph pluginGraph, Type pluginType) { _instance = instance; _memento = memento; _pluginGraph = pluginGraph; _pluginType = pluginType; }
public IPipelineGraph NewChild(PluginGraph parent) { var childGraph = parent.NewChild(); var instances = new ComplexInstanceGraph(_root, childGraph, ContainerRole.ProfileOrChild); var transientTracking = parent.TransientTracking == TransientTracking.DefaultNotTrackedAtRoot ? _root.Transients : new TrackingTransientCache(); return new PipelineGraph(childGraph, instances, _root, _root.Singletons, transientTracking); }
public void lifecyle_for_pluginType_not_explicitly_set_falls_back_to_parent() { var graph = new PluginGraph(); graph.Families[typeof(IGateway)].SetLifecycleTo<SingletonLifecycle>(); var pipeline = PipelineGraph.BuildRoot(graph).Profiles.For("Red"); pipeline.Instances.DefaultLifecycleFor(typeof(IGateway)) .ShouldBeOfType<SingletonLifecycle>(); }
public static IPipelineGraph BuildRoot(PluginGraph pluginGraph) { ITransientTracking transients = pluginGraph.TransientTracking == TransientTracking.DefaultNotTrackedAtRoot ? (ITransientTracking) new NulloTransientCache() : new TrackingTransientCache(); return new PipelineGraph(pluginGraph, new RootInstanceGraph(pluginGraph), null, pluginGraph.SingletonCache, transients); }
public void ScanForTypes(TypePool types, PluginGraph pluginGraph) { var registry = new Registry(); types.For(_assemblies, _filter).Each( type => _conventions.Each(c => c.Process(type, registry))); registry.As <IPluginGraphConfiguration>().Configure(pluginGraph); _postScanningActions.Each(x => x(pluginGraph)); }
public static PluginGraph BuildGraphFromAssembly(Assembly assembly) { var graph = new PluginGraph(); graph.Scan(x => x.Assembly(assembly)); graph.Seal(); return(graph); }
/// <summary> /// Creates a top level PluginGraph with the default policies /// </summary> /// <param name="profile"></param> /// <returns></returns> public static PluginGraph CreateRoot(string profile = null) { var graph = new PluginGraph(); graph.ProfileName = profile ?? "DEFAULT"; graph.Families[typeof(Func <>)].SetDefault(new FuncFactoryTemplate()); graph.Families[typeof(Func <,>)].SetDefault(new FuncWithArgFactoryTemplate()); graph.Families[typeof(Lazy <>)].SetDefault(new LazyFactoryTemplate()); return(graph); }
public void ScanForTypes(PluginGraph pluginGraph) { var registry = new Registry(); TypeRepository.FindTypes(_assemblies, TypeClassification.All, _filter.Matches) .ContinueWith(t => { t.Result.Each(type => _conventions.Each(c => c.Process(type, registry))); }).Wait(); registry.As <IPluginGraphConfiguration>().Configure(pluginGraph); _postScanningActions.Each(x => x(pluginGraph)); }
public void Apply(PluginGraph graph) { var registry = new Registry(); _interfaces.Each(@interface => { var expression = registry.For(@interface); ConfigureFamily(expression); _concretions.Where(x => x.CanBeCastTo(@interface)).Each(type => expression.Add(type)); }); registry.As <IPluginGraphConfiguration>().Configure(graph); }
public void RegisterSingleImplementations(PluginGraph graph) { var singleImplementationRegistry = new SingleImplementationRegistry(); _types.Each((pluginType, types) => { if (types.Count == 1) { singleImplementationRegistry.AddType(pluginType, types[0]); ConfigureFamily(singleImplementationRegistry.For(pluginType)); } }); singleImplementationRegistry.As <IPluginGraphConfiguration>().Configure(graph); }
internal void ScanForAll(PluginGraph pluginGraph) { var registry = new Registry(); pluginGraph.Types.For(_assemblies, _filter).Each( type => { _scanners.Each(x => x.Process(type, pluginGraph)); _conventions.Each(c => c.Process(type, registry)); }); registry.ConfigurePluginGraph(pluginGraph); _postScanningActions.Each(x => x(pluginGraph)); }
public TypePool(PluginGraph graph) { _types.OnMissing = assembly => { try { return(assembly.GetExportedTypes()); } catch (Exception ex) { graph.Log.RegisterError(170, ex, assembly.FullName); return(new Type[0]); } }; }
public PluginFamilyCollection(PluginGraph pluginGraph) { _pluginGraph = pluginGraph; _pluginFamilies = new Dictionary <Type, PluginFamily>(); }
public CloseGenericFamilyPolicy(PluginGraph graph) { _graph = graph; }