public IEnumerable<ActionCall> FindActions(TypePool types) { //var tpes = types.TypesMatching(t => t.Closes(typeof (StateMachine<>))); foreach(var sm in new List<Type>{typeof(TicketStateMachine)}) { //TODO: Where can I load things into the container - using ObjDef? var machine = (StateMachine)Activator.CreateInstance(sm); var t = typeof (StateMachineOptionsAction<>).MakeGenericType(sm); var ta = new ActionCall(t, t.GetMethod("Execute", BindingFlags.Public | BindingFlags.Instance)); //can I build the route here? yield return ta; var tt = typeof(StateMachineInstanceOptionsAction<>).MakeGenericType(sm); yield return new ActionCall(tt, tt.GetMethod("Execute", BindingFlags.Public | BindingFlags.Instance)); var ttt = typeof(StateMachineCurrentStateAction<>).MakeGenericType(sm); yield return new ActionCall(ttt, ttt.GetMethod("Execute", BindingFlags.Public | BindingFlags.Instance)); foreach (var @event in machine.Events) { //need to track the event name //between here and the event url generation //so I used a custom ActionCall extension var eventName = @event.Name; var et = typeof (StateMachineRaiseEventAction<,>).MakeGenericType(sm, @event.GetType()); var call = new EventActionCall(eventName, et, et.GetMethod("Execute", BindingFlags.Public | BindingFlags.Instance)); yield return call; } } }
public void removing_the_called_assembly() { var pool = new TypePool(GetType().Assembly); pool.IgnoreCallingAssembly(); pool.Assemblies.ShouldNotContain(GetType().Assembly); }
public IEnumerable<ActionCall> FindActions(TypePool types) { var awesomeEntities = types.EntityTypes(); var openHandlers = new[] { typeof (RestfulCreateHandler<>), typeof (RestfulPatchHandler<>), typeof (RestfulDeleteHandler<>), typeof (RestfulFindHandler<>), typeof (RestfulIndexHandler<>), typeof (AwesomeCreateHandler<>), typeof (AwesomeEditHandler<>) }; foreach (var awesomeEntity in awesomeEntities) { foreach(var openHandler in openHandlers) { var closedHandler = openHandler.MakeGenericType(awesomeEntity); var closedMethod = closedHandler.GetMethod("Execute", BindingFlags.Public | BindingFlags.Instance); //should drive from RestfulHandler guard(closedHandler, closedMethod); yield return new ActionCall(closedHandler, closedMethod); } } }
public IEnumerable<ActionCall> FindActions(TypePool types) { var actionCalls = new List<ActionCall>(); var viewModels = types.TypesMatching(t => IsAssignableFromGenericInterface(typeof(IEntityUpdateable<>), t)); foreach (var viewModel in viewModels) { Type entityType = null; foreach (Type interfaceType in viewModel.GetInterfaces()) { if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IEntityUpdateable<>)) { entityType = interfaceType.GetGenericArguments().Single(); break; } } Type queryType = typeof(SaveHandler<,>).MakeGenericType(viewModel, entityType); MethodInfo retrievalMethod = queryType.GetMethod("Save"); actionCalls.Add(new ActionCall(queryType, retrievalMethod)); } return actionCalls; }
public void SetUp() { graph = new BehaviorGraph(null); matcher = new ActionSourceMatcher(); pool = new TypePool(); }
public void Setup() { var types = new TypePool(); types.AddAssembly(GetType().Assembly); _runner = new ViewEngineSettings(); }
public void SetUp() { var pool = new TypePool(); pool.AddAssembly(Assembly.GetExecutingAssembly()); views = new WebFormViewFacility().FindViews(pool); }
public AssemblyScanner() { _types = new TypePool(GetType().Assembly); _typeFilters = new CompositeFilter <Type>(); IncludeTypes(t => true); }
public IEnumerable<ActionCall> FindActions(TypePool types) { var awesomeEntities = (from entities in types.TypesMatching(AwesomeConfiguration.AwesomeEntities) where entities.IsConcrete() select entities).ToList() .Distinct(); var openHandlers = new[] { typeof (RestfulCreateHandler<>), typeof (RestfulPatchHandler<>), typeof (RestfulDeleteHandler<>), typeof (RestfulFindHandler<>), typeof (RestfulIndexHandler<>), typeof (AwesomeCreateHandler<>), typeof (AwesomeEditHandler<>) }; foreach (var awesomeEntity in awesomeEntities) { foreach(var openHandler in openHandlers) { var closedHandler = openHandler.MakeGenericType(awesomeEntity); var closedMethod = closedHandler.GetMethod("Execute", BindingFlags.Public | BindingFlags.Instance); //should drive from RestfulHandler guard(closedHandler, closedMethod); yield return new ActionCall(closedHandler, closedMethod); } } }
public void Configure(ServiceRegistry services) { var types = _applies.BuildPool(TypePool.FindTheCallingAssembly()); var matchedTypes = types.TypesMatching(_typeFilters.Matches); _conventions .Each(convention => convention.Register(matchedTypes, services)); }
public IEnumerable<ActionCall> FindActions(TypePool types) { return types.TypesMatching(t => t.Name.EndsWith("Endpoint") || t.Name.EndsWith("Endpoints")) .SelectMany(type => { var methods = type.GetMethods().Where(ActionSource.IsCandidate); return methods.Select(m => new ActionCall(type, m)); }); }
public IEnumerable <ActionCall> FindActions(TypePool types) { return(types.TypesMatching(t => t.Name.EndsWith("Endpoint") || t.Name.EndsWith("Endpoints")) .SelectMany(type => { var methods = type.GetMethods().Where(ActionSource.IsCandidate); return methods.Select(m => new ActionCall(type, m)); })); }
public void should_return_all_types_with_full_name() { var pool = new TypePool(GetType().Assembly) {ShouldScanAssemblies = true }; pool.AddType(generateType("namespace FubuMVC.Core{public class Endpoint{}}", "FubuMVC.Core.Endpoint")); pool.AddType(typeof(Core.Endpoint)); pool.TypesWithFullName(typeof(Core.Endpoint).FullName).ShouldHaveCount(2); }
public void SetUp() { var pool = new TypePool(null){ ShouldScanAssemblies = true }; pool.AddAssembly(Assembly.GetExecutingAssembly()); views = new WebFormViewFacility().FindViews(pool, new BehaviorGraph()); }
public IEnumerable<IViewToken> FindViews(BehaviorGraph graph) { var types = new TypePool(); types.AddAssemblies(AppDomain.CurrentDomain.GetAssemblies()); types.IgnoreExportTypeFailures = true; return types.TypesMatching(t => t.IsConcrete() && t.Closes(typeof (FubuHtmlDocument<>)) && !t.Equals(typeof(FubuHtmlDocument<>))) .Select(t => new HtmlDocumentViewToken(t)); }
public IEnumerable<IViewToken> FindViews(TypePool types) { // clean up pending return _templateRegistry .AllTemplates() .Where(x => x.Descriptor is ViewDescriptor<IRazorTemplate>) .Select(x => x.Descriptor.As<ViewDescriptor<IRazorTemplate>>()) .Where(x => x.HasViewModel()) .Select(x => new RazorViewToken(x)); }
public IEnumerable<IViewToken> FindViews(TypePool types, BehaviorGraph graph) { return _composer.Compose(types) .AllTemplates() // TODO : Clean this up .Where(x => x.Descriptor is ViewDescriptor) .Select(x => x.Descriptor.As<ViewDescriptor>()) .Where(x => x.HasViewModel()) .Select(x => new SparkViewToken(x)); }
/// <summary> /// All types in the AppDomain in non dynamic assemblies /// </summary> public static TypePool AppDomainTypes() { var pool = new TypePool { IgnoreExportTypeFailures = true }; pool.AddAssemblies(AppDomain.CurrentDomain.GetAssemblies().Where(x => !x.IsDynamic)); return(pool); }
public AssemblyScanner() { _types = new TypePool(GetType().Assembly) { IgnoreExportTypeFailures = false }; _typeFilters = new CompositeFilter <Type>(); IncludeTypes(t => true); }
public IEnumerable<IViewToken> FindViews(TypePool types, BehaviorGraph graph) { // clean up pending return _templateRegistry .AllTemplates() .Where(x => x.Descriptor is ViewDescriptor) .Select(x => x.Descriptor.As<ViewDescriptor>()) .Where(x => x.HasViewModel()) .Select(x => new SparkViewToken(x)); }
public void FindActions_should_skip_view_models_that_dont_have_an_entity_type_attribute() { IActionSource actionSource = new ListingHandlerActionSource(); TypePool typePool = new TypePool(Assembly.GetExecutingAssembly()); var actionCalls = actionSource.FindActions(typePool).ToList(); Assert.GreaterOrEqual(actionCalls.Count, 1); Assert.IsFalse(actionCalls.Any( ac => ac.HandlerType == typeof(ListingHandler<NoEntityTypeViewModel, StubEntity>) )); }
public void FindActions_should_return_actions_calls_for_view_models_only() { IActionSource actionSource = new ListingHandlerActionSource(); TypePool typePool = new TypePool(Assembly.GetExecutingAssembly()); var actionCalls = actionSource.FindActions(typePool).ToList(); Assert.GreaterOrEqual(actionCalls.Count, 1); Assert.IsTrue(actionCalls.Any( ac => ac.HandlerType == typeof(ListingHandler<StubViewModel, StubEntity>) )); }
public void Configure(BehaviorGraph graph) { var rules = graph.Settings.Get <AccessorRules>(); TypePool.AppDomainTypes().TypesMatching(x => x.CanBeCastTo <IAccessorRulesRegistration>() && x.IsConcreteWithDefaultCtor() && !x.IsOpenGeneric()). Distinct().Select(x => { return(Activator.CreateInstance(x).As <IAccessorRulesRegistration>()); }) .Each(x => x.AddRules(rules)); graph.Settings.Replace(rules); }
public TypePool Types() { var types = new TypePool(); if (ApplicationAssembly != null) { types.AddAssembly(ApplicationAssembly); } types.AddAssemblies(PackageRegistry.PackageAssemblies); return(types); }
public IEnumerable<ActionCall> FindActions(Assembly applicationAssembly) { var types = new TypePool(); types.AddAssemblies(AppDomain.CurrentDomain.GetAssemblies()); types.IgnoreExportTypeFailures = true; return types.TypesMatching(type => type.IsConcreteTypeOf<ILookupProvider>()).Select(type => { var method = GetLookupMethod(type); return new ActionCall(type, method); }); }
private static TypePool getTypes() { var types = new TypePool(ConfigurationGraph.FindTheCallingAssembly()); var filter = new CompositeFilter<Assembly>(); filter.Excludes.Add(a => a.IsDynamic); filter.Excludes.Add(a => types.HasAssembly(a)); filter.Includes += (t => true); types.AddSource(() => AppDomain.CurrentDomain.GetAssemblies().Where(filter.MatchesAll)); return types; }
public void FindActions_should_return_actions_calls_for_retrieve_method() { IActionSource actionSource = new ListingHandlerActionSource(); TypePool typePool = new TypePool(Assembly.GetExecutingAssembly()); var actionCalls = actionSource.FindActions(typePool).ToList(); Assert.GreaterOrEqual(actionCalls.Count, 1); Assert.IsTrue(actionCalls.Any( ac => ac.Method.Name == "Retrieve" && ac.Method.GetParameters()[0].ParameterType == typeof(ListingOf<StubViewModel>) )); }
public IEnumerable<IViewToken> FindViews(TypePool types) { IEnumerable<Type> actionTypes = types.TypesMatching(_sparkActionEndPointConventionFilter); var viewTokens = new List<IViewToken>(); actionTypes.Each(actionType => { var sparkBatchEntry = new SparkBatchEntry {ControllerType = actionType}; IList<SparkViewDescriptor> descriptors = _viewFactory.CreateDescriptors(sparkBatchEntry, _getActionNameFromCallConvention); viewTokens.Add(new SparkViewToken(descriptors)); }); return viewTokens; }
public IEnumerable<IViewToken> FindViews(TypePool types) { IEnumerable<Type> actionTypes = types.TypesMatching(_actionEndPointFilter); var viewTokens = new List<IViewToken>(); actionTypes.Each(actionType => { var sparkBatchEntry = new SparkBatchEntry { ControllerType = actionType }; string viewLocatorName = _getViewLocatorNameFromActionType(actionType); IList<SparkViewDescriptor> descriptors = _viewFactory.CreateDescriptors(sparkBatchEntry, viewLocatorName); viewTokens.Add(new SparkViewToken(descriptors)); }); return viewTokens; }
public void Setup() { var types = new TypePool(null); _observer = new RecordingConfigurationObserver(); _action = ActionCall.For<ViewsForActionFilterTesterController>(x => x.AAction()); _fromFindsOne = new FakeViewToken(); _fromSecondFindsOne = new FakeViewToken(); _views = new ViewBag(new IViewToken[] { _fromFindsOne, _fromSecondFindsOne }); _filterThatFindsNone = createFilterThatReturns(new IViewToken[0]); _firstFilterThatFindsExactlyOne = createFilterThatReturns(_fromFindsOne); _secondFilterThatFindsExactlyOne = createFilterThatReturns(_fromSecondFindsOne); _filterThatFindsMultiple = createFilterThatReturns(_fromFindsOne, _fromSecondFindsOne); _viewAttacher = new ViewAttacher(types); }
public static IEnumerable<IFubuRegistryExtension> FindAllExtensions() { if (!PackageRegistry.PackageAssemblies.Any()) return new IFubuRegistryExtension[0]; var pool = new TypePool(null); pool.AddAssemblies(PackageRegistry.PackageAssemblies); // Yeah, it really does have to be this way return pool.TypesMatching( t => hasDefaultCtor(t) && t.GetInterfaces().Any(i => i.FullName == typeof (IFubuRegistryExtension).FullName)) .Select(buildExtension); }
public IEnumerable<IViewToken> FindViews(TypePool types, BehaviorGraph graph) { // TODO: Make it not filter against view model as the // default view attacher conventions will do this. // Opens up for returning view with no model in edge cases // and add custom view attacher convention. return _templateRegistry .AllTemplates() .Where(x => x.Descriptor is ViewDescriptor) .Select(x => x.Descriptor.As<ViewDescriptor>()) .Where(x => x.HasViewModel()) .Select(x => new SparkViewToken(x)); }
public IEnumerable<Type> FindApplicationSourceTypes(ApplicationSettings settings) { var assemblies = AssembliesFromApplicationBaseDirectory(x => true); if (!assemblies.Any()) { var assemblyName = Path.GetFileName(settings.GetApplicationFolder()); assemblies = AssembliesFromApplicationBaseDirectory(x => x.GetName().Name == assemblyName); } var types = new TypePool {IgnoreExportTypeFailures = true}; types.AddAssemblies(assemblies); return types.TypesMatching(x => x.CanBeCastTo<IApplicationSource>() && x.IsConcreteWithDefaultCtor()); }
public BehaviorGraph() { _log = new ConfigLog(this); _settings = new SettingsCollection(null); _settings.Replace(SessionStateRequirement.RequiresSessionState); RouteIterator = new SortByRouteRankIterator(); // can override in a registry TypeResolver = new TypeResolver(); _services.AddService <ITypeResolver>(TypeResolver); Types = new TypePool(null); // need a default for some tests }
public IEnumerable<IViewToken> FindViews(TypePool types, BehaviorGraph graph) { var viewTokens = new List<IViewToken>(); graph .Actions() .Where(call => _policyResolver.HasMatchFor(call)) .Each(call => { var sparkBatchEntry = new SparkBatchEntry { ControllerType = call.HandlerType }; string viewLocatorName = _policyResolver.ResolveViewLocator(call); IList<SparkViewDescriptor> descriptors = _viewFactory.CreateDescriptors(sparkBatchEntry, viewLocatorName); viewTokens.Add(new SparkViewToken(descriptors)); }); return viewTokens; }
public IEnumerable<ActionCall> FindActions(TypePool types) { var methodName = ReflectionHelper.GetMethod<ChannelWriter<Topic>>(x => x.Write(null)) .Name; var topicTypes = types.TypesMatching(x => x.IsConcreteTypeOf<Topic>()); foreach (var topicType in topicTypes) { var handlerType = typeof (ChannelWriter<>).MakeGenericType(topicType); var method = handlerType.GetMethod(methodName); yield return new ActionCall(handlerType, method); } }
public void Configure(BehaviorGraph graph) { var rules = graph.Settings.Get <AccessorRules>(); var types = new TypePool(null); types.AddAssemblies(graph.Types.Assemblies.Union(PackageRegistry.PackageAssemblies)); types.TypesMatching(x => x.CanBeCastTo <IAccessorRulesRegistration>() && x.IsConcreteWithDefaultCtor()). Distinct().Select(x => { return(Activator.CreateInstance(x).As <IAccessorRulesRegistration>()); }) .Each(x => x.AddRules(rules)); graph.Services.AddService(rules); }
public IEnumerable<ActionCall> FindActions(TypePool types) { var stateMachines = types.TypesMatching(t => t.Closes(typeof (StateMachine<>))); foreach(var sm in stateMachines) { //TODO: Where can I load things into the container - using ObjDef? var machine = (StateMachine)Activator.CreateInstance(sm); var t = typeof (StateMachineOptionsAction<>).MakeGenericType(sm); var ta = new ActionCall(t, t.GetMethod("Execute", BindingFlags.Public | BindingFlags.Instance)); yield return ta; //need to fix this //current state? var tt = typeof(StateMachineInstanceOptionsAction<>).MakeGenericType(sm); yield return new ActionCall(tt, tt.GetMethod("Execute", BindingFlags.Public | BindingFlags.Instance)); var ttt = typeof(StateMachineCurrentStateAction<>).MakeGenericType(sm); yield return new ActionCall(ttt, ttt.GetMethod("Execute", BindingFlags.Public | BindingFlags.Instance)); foreach (var @event in machine.Events) { //need to track the event name //between here and the event url generation //so I used a custom ActionCall extension var eventName = @event.Name; var tttt = typeof (StateMachineRaiseSimpleEventAction<>).MakeGenericType(sm); var eventType = @event.GetType(); if (eventType != typeof (SimpleEvent)) { tttt = typeof (StateMachineRaiseDataEventAction<,>).MakeGenericType(sm, eventType); } var call = new EventActionCall(eventName, tttt, tttt.GetMethod("Execute", BindingFlags.Public | BindingFlags.Instance)); yield return call; } yield break; } }
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log) { var pool = new TypePool(); pool.AddAssemblies(AppDomain.CurrentDomain.GetAssemblies()); pool.IgnoreExportTypeFailures = true; pool.TypesMatching(type => type.IsConcreteWithDefaultCtor() && type.CanBeCastTo<TopicRegistry>()) .Each(type => { // All we have to do is create it to work Activator.CreateInstance(type); }); TopicGraph.AllTopics.All().Each(node => { node.Url = _urls.UrlFor(node.TopicType); if (!node.Url.StartsWith("/")) { node.Url = "/" + node.Url; // has to be an absolute } }); }
public void BuildBehaviors(TypePool pool, BehaviorGraph graph) { _graph = graph; buildActions(pool).Each(registerBehavior); _graph = null; }
private IEnumerable <ActionCall> buildActions(TypePool types) { return(_actionSources.SelectMany(actionSource => actionSource.FindActions(types))); }
public BehaviorAggregator(TypePool types, IEnumerable <IActionSource> sources) { _types = types; _sources = sources; }
public IEnumerable <ActionCall> FindActions(TypePool types) { return(_actionType.PublicInstanceMethods().Where(_methodFilter.Matches) .Select(method => new ActionCall(_actionType, method))); }
public IEnumerable <ActionCall> FindActions(TypePool types) { return(types.TypesMatching(_typeFilters.Matches).SelectMany(actionsFromType)); }