internal LoaderScriptExtension(string path) : base(path) { _script = File.ReadAllText(Path); _usings = new Usings(); _commands = new List <ScriptedCommand>(); _imports = new List <AssemblyName>(); _container = new ScriptedCommandContainer(this); ExtensionStore.InitExtension(this); Description = System.IO.Path.GetFileName(Path); Load(); foreach (var command in _commands) { var lcInfo = new LoaderCommand(this, command); command.LoaderCommand = lcInfo; AddItem(lcInfo); } var lccInfo = new LoaderCommandContainer(this, _container, typeof(ScriptedCommandContainer)); ExtensionStore.InitCommandContainer(lccInfo, Items.Cast <LoaderCommand>()); AddItem(lccInfo); }
void LoadCommandContainer(TypeDescriptor containerType, AssemblyDescriber describer) { if (containerType.IsAbstract || !containerType.HasPublicParameterlessConstructor) { return; } var methods = describer.GetPublicMethods(containerType); var cmdMethods = (from method in methods let commandAttr = method.APIAttributes.OfType <CommandAttribute>().FirstOrDefault() where commandAttr != null select new { method, commandAttr }).ToArray(); if (cmdMethods.Length == 0) { return; } var dupeCommandNames = from i in cmdMethods group i by i.commandAttr.Name into g where g.Count() > 1 select g; if (dupeCommandNames.Any()) { throw new LoaderItemInitException(string.Format("Duplicate command names in container {0}", containerType)); } var container = CreateLoaderInstance <CommandContainer>(containerType); var commandInfos = new List <LoaderCommand>(); foreach (var method in cmdMethods) { try { var reflectedCmd = new ReflectedCommand(container, method.method, method.commandAttr); var lcInfo = new LoaderCommand(this, reflectedCmd); reflectedCmd.LoaderCommand = lcInfo; commandInfos.Add(lcInfo); } catch (Exception ex) { Debug.WriteLine("Could not initialize command {0} in container {1}: {2}", method.method.Name, containerType, ex.Message); } } var lccInfo = new LoaderCommandContainer(this, container, containerType); ExtensionStore.InitCommandContainer(lccInfo, commandInfos); container.Initialize(Hooks); AddItems(commandInfos); AddItem(lccInfo); }
// [Fact] public void CreateStoreForCurrentDirectoryShouldFindExportsInDirectory() { // Given stores created for types in different assemblies ExtensionStore myStore = ExtensionStore.CreateStoreForCurrentDirectory <MyExportType>(); ExtensionStore querierStore = ExtensionStore.CreateStoreForCurrentDirectory <ASTNodeFormatterFactory>(); // When I query exports // Then exports for all assemblies should be found Assert.Equal(2, myStore.GetExports <MyExportType>().Count()); Assert.NotEmpty(querierStore.GetExports <ASTNodeFormatterFactory>()); }
public void CreateAssemblyStoreShouldFindTypesInAssembly() { // Given a store for MyExportType ExtensionStore store = ExtensionStore.CreateAssemblyStore <MyExportType>(GetType().GetTypeInfo().Assembly); // Then should get any export for this type and subtypes Assert.Equal(2, store.GetExports <MyExportType>().Count()); // But for a different type, expect throw as the store only contains MyExportType Assert.Throws <InvalidCastException>(() => store.GetExports <MyOtherType>().Count()); }
public void CreateDefaultLoaderShouldFindTypesOnlyInMainAssembly() { // Given a store created using CreateDefaultLoader // Then not should find exports from a different assembly ExtensionStore store = ExtensionStore.CreateDefaultLoader <MyExportType>(); Assert.Equal(0, store.GetExports <MyExportType>().Count()); // And should not find exports that are defined in the ServiceLayer assembly store = ExtensionStore.CreateDefaultLoader <ASTNodeFormatterFactory>(); Assert.Empty(store.GetExports <ASTNodeFormatterFactory>()); }
void LoadFacetFactory(TypeDescriptor factoryType, AssemblyDescriber describer) { if (factoryType.IsAbstract || !factoryType.HasPublicParameterlessConstructor) { return; } var attr = describer.GetClassAttributes(factoryType).OfType <FacetFactoryAttribute>().FirstOrDefault(); var factory = CreateLoaderInstance <IFacetFactory>(factoryType); var info = new LoaderFacetFactory(this, factory, factoryType, attr); ExtensionStore.InitFacetFactory(info); factory.Initialize(Hooks); AddItem(info); }
void LoadFacetType(TypeDescriptor type, AssemblyDescriber describer) { if (!type.IsInterface && !type.IsAbstract) { if (!type.GetImplementedTypes(true).Any(x => x.IsInterface && x.Implements(typeof(IFacet)))) { throw new LoaderItemInitException("None of the interfaces implemented by facet class implements IFacet"); } } LoaderAmbientFacet ambientInfo = null; if (!type.IsInterface) { var ambientAttr = describer.GetClassAttributes(type).OfType <AmbientFacetAttribute>().FirstOrDefault(); if (ambientAttr != null) { if (!type.HasPublicParameterlessConstructor || type.IsAbstract) { throw new LoaderItemInitException("No public parameterless constructor for ambient facet type"); } var facet = CreateLoaderInstance <IFacet>(type); facet.Initialize(Hooks); ambientInfo = new LoaderAmbientFacet(this, ambientAttr.Token, facet, new FacetMoniker(ambientAttr.Token, type, facet.DisplayName)); } } var info = new LoaderFacetType(this, type); ExtensionStore.InitFacetType(info); AddItem(info); if (ambientInfo != null) { AddItem(ambientInfo); } }
void Initialize(AssemblyDescriber describer, TypeDescriptor[] types) { ExtensionStore.InitExtension(this); foreach (var type in types .OrderBy(x => x.IsInterface ? 0 : 1) .ThenBy(x => x.Implements(typeof(IFacet)) ? 0 : 1)) { try { if (type.Implements(typeof(IFacet))) { LoadFacetType(type, describer); } else if (type.Implements(typeof(IFacetFactory))) { LoadFacetFactory(type, describer); } else if (type.Implements(typeof(CommandContainer))) { LoadCommandContainer(type, describer); } else if (type.Implements(typeof(IConfigurator))) { if (!type.IsAbstract && type.HasPublicParameterlessConstructor) { AddItem(new LoaderConfiguratorType(this, type)); } } } catch (LoaderItemInitException e) { Debug.WriteLine("Could not load type {0}: {1}", type.FullName, e.Message); } } }
/// <summary> /// Clears this instance. /// </summary> public void Clear() { Context?.Clear(); DataStore?.Clear(); ExtensionStore?.Clear(); }