public override IEnumerable <IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var statements = match.GetMatchedElementList("statements").Cast <ICSharpStatement>(); var collectedTypes = statements.SelectMany(statement => { var returnTypeCollector = new ReturnTypeCollector(new UniversalContext(statement.GetPsiModule())); statement.ProcessThisAndDescendants(returnTypeCollector); return(returnTypeCollector.CollectedTypes); }); foreach (var type in collectedTypes) { var declaredType = type as IDeclaredType; if (declaredType != null) { var typeElement = declaredType.GetTypeElement(); if (typeElement != null) { yield return(new ElementBasedOnRegistration(registrationRootElement, typeElement)); } } } } }
public override IEnumerable <IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { IExpressionStatement parentExpression = GetParentExpressionStatemenmt(registrationRootElement); if (parentExpression == null) { yield break; } IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var arguments = match.GetMatchedElementList("assemblies").Cast <ICSharpArgument>(); IEnumerable <IModule> modules = arguments.SelectNotNull(argument => ModuleExtractor.GetTargetModule(argument.Value)); IEnumerable <FilteredRegistrationBase> basedOnRegistrations = basedOnPatterns.SelectMany( basedOnPattern => basedOnPattern.GetBasedOnRegistrations(parentExpression.Expression)).ToList(); foreach (IModule module in modules) { // todo blech, fix this yield return(new CompositeRegistration(registrationRootElement, basedOnRegistrations.Union( new ComponentRegistrationBase[] { new DefaultScanAssemblyRegistration(registrationRootElement), new ModuleBasedOnRegistration(registrationRootElement, module) }))); } } }
public override IEnumerable <IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { // todo this is duplicated, needs refactoring! // This entire thing is one big hack. Need to come back to it one day :) // There is (currently) no way to create a pattern that would match the Scan() call with implicit 'this' in ReSharper SSR // (i.e. a call to Scan being made withing a method, located in the Registry class) // Therefore I'm only matching by the method name only, and later verifying that the method indeed belongs to StructureMap, by // making sure the invocation's qualifier derived from global::StructureMap.Configuration.DSL.IRegistry if (!registrationRootElement.IsContainerCall(Constants.StructureMapRegistryTypeName)) { yield break; } IInvocationExpression invocationExpression = registrationRootElement.GetInvocationExpression(); if (invocationExpression == null) { yield break; } IStructuralMatchResult match = Match(invocationExpression); if (match.Matched) { var invocationExpressions = match.GetMatchedElementList("statements") .OfType <IExpressionStatement>() .WhereNotNull() .Select(statement => statement.Expression) .OfType <IInvocationExpression>() .ToList(); var registrations = (from expression in invocationExpressions from basedOnPattern in basedOnPatterns from registration in basedOnPattern.GetBasedOnRegistrations(expression) select registration).ToList(); if (!registrations.Any()) { yield break; } var moduleRegistrations = (from expression in invocationExpressions from pattern in fromAssemblyPatterns from registration in pattern.GetComponentRegistrations(expression) select registration).ToList(); foreach (var moduleRegistration in moduleRegistrations) { yield return(new CompositeRegistration(registrationRootElement, registrations.Union(new[] { moduleRegistration }))); } } }
public override IEnumerable <IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { foreach (IBasedOnPattern basedOnPattern in BasedOnPatterns) { foreach (BasedOnRegistrationBase basedOnRegistration in basedOnPattern.GetBasedOnRegistrations(registrationRootElement)) { IEnumerable <ICSharpArgument> matchedArguments = match.GetMatchedElementList("services").OfType <ICSharpArgument>(); IEnumerable <ITypeElement> typeElements = matchedArguments.SelectMany(argument => GetRegisteredTypes(match, argument.Value)); yield return(new TypesBasedOnRegistration(typeElements, basedOnRegistration)); } } } }
public override IEnumerable <IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { IEnumerable <IInvocationExpression> invocationExpressions = match.GetMatchedElementList("arguments").Cast <ICSharpArgument>() .Select(argument => argument.Value) .OfType <IInvocationExpression>(); return(from argumentPattern in argumentsPatterns from expression in invocationExpressions from registration in argumentPattern.GetComponentRegistrations(expression) select registration); } return(Enumerable.Empty <IComponentRegistration>()); }
public override IEnumerable <IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { var parentExpression = registrationRootElement.GetParentExpression <IExpressionStatement>(); if (parentExpression == null) { yield break; } IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var statements = match.GetMatchedElementList("statements").Cast <ICSharpStatement>().ToList(); var collectedTypes = statements.SelectMany(statement => { var returnTypeCollector = new ReturnTypeCollector(new UniversalContext(statement.GetPsiModule())); statement.ProcessThisAndDescendants(returnTypeCollector); return(returnTypeCollector.CollectedTypes); }); IEnumerable <FilteredRegistrationBase> basedOnRegistrations = basedOnPatterns.SelectMany( basedOnPattern => basedOnPattern.GetBasedOnRegistrations(parentExpression.Expression)).ToList(); foreach (var type in collectedTypes) { var declaredType = type as IDeclaredType; if (declaredType != null) { var typeElement = declaredType.GetTypeElement(); if (typeElement != null) { yield return(new CompositeRegistration(registrationRootElement, new[] { new ServiceRegistration(registrationRootElement, typeElement) } .Concat(basedOnRegistrations))); } } } } }
public override IEnumerable <IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var registrations = (from p in basedOnPatterns from registration in p.GetBasedOnRegistrations(registrationRootElement) select registration).ToList(); if (registrations.Any()) { foreach (FilteredRegistrationBase basedOnRegistration in registrations) { IEnumerable <ICSharpArgument> matchedArguments = match.GetMatchedElementList("services").OfType <ICSharpArgument>(); IEnumerable <ITypeElement> typeElements = matchedArguments.SelectMany(argument => argument.Value.GetRegisteredTypes()); yield return(new TypesBasedOnRegistration(typeElements, basedOnRegistration)); } } } }
protected override INamespace GetNamespaceElement(IStructuralMatchResult match, out bool includeSubnamespaces) { var arguments = match.GetMatchedElementList("arguments").Cast<ICSharpArgument>().ToArray(); INamespace namespaceElement = null; if (arguments.Length > 0) { namespaceElement = GetNamespaceDeclaration(arguments[0].Value); } includeSubnamespaces = false; if (arguments.Length == 2) { ICSharpArgument boolArgument = arguments[1]; if (boolArgument.Value.ConstantValue != null && boolArgument.Value.ConstantValue.IsBoolean()) { includeSubnamespaces = Convert.ToBoolean(boolArgument.Value.ConstantValue.Value); } } return namespaceElement; }
protected override IEnumerable<FilteredRegistrationBase> DoCreateRegistrations(ITreeNode registrationRootElement, IStructuralMatchResult match) { var arguments = match.GetMatchedElementList("arguments").Cast<ICSharpArgument>(); foreach (var argument in arguments) { // match typeof() expressions var typeOfExpression = argument.Value as ITypeofExpression; if (typeOfExpression != null) { var argumentType = typeOfExpression.ArgumentType as IDeclaredType; if (argumentType != null) { var typeElement = argumentType.GetTypeElement(); if (typeElement == null) // can happen if the typeof() expression is empty { yield break; } yield return new ServiceRegistration(registrationRootElement, typeElement); } } } }
protected override IEnumerable <FilteredRegistrationBase> DoCreateRegistrations(ITreeNode registrationRootElement, IStructuralMatchResult match) { var arguments = match.GetMatchedElementList("arguments").Cast <ICSharpArgument>(); foreach (var argument in arguments) { // match typeof() expressions var typeOfExpression = argument.Value as ITypeofExpression; if (typeOfExpression != null) { var argumentType = typeOfExpression.ArgumentType as IDeclaredType; if (argumentType != null) { var typeElement = argumentType.GetTypeElement(); if (typeElement == null) // can happen if the typeof() expression is empty { yield break; } yield return(new ServiceRegistration(registrationRootElement, typeElement)); } } } }
protected override INamespace GetNamespaceElement(IStructuralMatchResult match, out bool includeSubnamespaces) { var arguments = match.GetMatchedElementList("arguments").Cast<ICSharpArgument>().ToArray(); return NamespaceExtractor.GetNamespace(arguments, out includeSubnamespaces); }
protected override INamespace GetNamespaceElement(IStructuralMatchResult match, out bool includeSubnamespaces) { var arguments = match.GetMatchedElementList("arguments").Cast <ICSharpArgument>().ToArray(); return(NamespaceExtractor.GetNamespace(arguments, out includeSubnamespaces)); }