コード例 #1
0
        private static void Configure(AsyncGenerator configuration, CancellationTokens config, IFluentProjectCancellationTokenConfiguration fluentConfig)
        {
            if (config.Guards.HasValue)
            {
                fluentConfig.Guards(config.Guards.Value);
            }
            if (config.MethodParameter.Any())
            {
                fluentConfig.ParameterGeneration(CreateParameterGenerationFunction(configuration, config.MethodParameter));
            }
            if (config.WithoutCancellationToken.Any() || config.RequiresCancellationToken.Any())
            {
                foreach (ExecutionPhase value in Enum.GetValues(typeof(ExecutionPhase)))
                {
                    var withoutTokenGroup  = config.WithoutCancellationToken.GroupBy(o => o.ExecutionPhase).FirstOrDefault(o => o.Key == value);
                    var requiresTokenGroup = config.RequiresCancellationToken.GroupBy(o => o.ExecutionPhase).FirstOrDefault(o => o.Key == value);
                    if (withoutTokenGroup != null || requiresTokenGroup != null)
                    {
                        fluentConfig.RequiresCancellationToken(
                            CreateMethodNullablePredicate(configuration,
                                                          withoutTokenGroup?.ToList() ?? new List <MethodFilter>(),
                                                          requiresTokenGroup?.ToList() ?? new List <MethodFilter>()
                                                          ), value);
                    }
                }

                fluentConfig.RequiresCancellationToken(CreateMethodNullablePredicate(configuration,
                                                                                     config.WithoutCancellationToken, config.RequiresCancellationToken));
            }
        }
コード例 #2
0
        public virtual void Configure(AsyncGenerator configuration, Solution solution, IFluentSolutionConfiguration solutionConfiguration, Assembly assembly)
        {
            if (solution.ApplyChanges.HasValue)
            {
                solutionConfiguration.ApplyChanges(solution.ApplyChanges.Value);
            }
            if (solution.ConcurrentRun.HasValue)
            {
                solutionConfiguration.ConcurrentRun(solution.ConcurrentRun.Value);
            }
            if (!string.IsNullOrEmpty(solution.TargetFramework))
            {
                solutionConfiguration.TargetFramework(solution.TargetFramework);
            }

            foreach (var item in solution.SuppressDiagnosticFailures)
            {
                solutionConfiguration.SuppressDiagnosticFailures(item.Pattern);
            }

            // Configure projects
            foreach (var projectConfig in solution.Projects)
            {
                solutionConfiguration.ConfigureProject(projectConfig.Name, o => Configure(configuration, projectConfig, o, assembly));
            }
        }
コード例 #3
0
        public virtual void Configure(AsyncGenerator configuration, Project project, IFluentProjectConfiguration projectConfiguration, Assembly assembly)
        {
            if (project.ApplyChanges.HasValue)
            {
                projectConfiguration.ApplyChanges(project.ApplyChanges.Value);
            }
            if (project.ConcurrentRun.HasValue)
            {
                projectConfiguration.ConcurrentRun(project.ConcurrentRun.Value);
            }
            if (!string.IsNullOrEmpty(project.TargetFramework))
            {
                projectConfiguration.TargetFramework(project.TargetFramework);
            }

            foreach (var item in project.SuppressDiagnosticFailures)
            {
                projectConfiguration.SuppressDiagnosticFailures(item.Pattern);
            }

            projectConfiguration.ConfigureAnalyzation(o => Configure(configuration, project.Analyzation, o));
            projectConfiguration.ConfigureTransformation(o => Configure(configuration, project.Transformation, o));

            if (!project.RegisterPlugin.Any())
            {
                return;
            }
            var assemblies = AppDomain.CurrentDomain.GetAssemblies()
                             .Where(o => !o.IsDynamic)
                             .Distinct()
                             .GroupBy(o => o.GetName().Name)    // there may be multiple versions of the same assembly
                             .ToDictionary(o => o.Key, o => o.First());

            foreach (var plugin in project.RegisterPlugin)
            {
                if (!string.IsNullOrEmpty(plugin.AssemblyName) && !assemblies.ContainsKey(plugin.AssemblyName))
                {
                    assemblies[plugin.AssemblyName] = Assembly.Load(plugin.AssemblyName);
                }
                if (string.IsNullOrEmpty(plugin.AssemblyName) && assembly == null)
                {
                    throw new InvalidOperationException($"Assembly name must be provided for type {plugin.Type}.");
                }

                var type = string.IsNullOrEmpty(plugin.AssemblyName)
                                        ? assembly.GetExportedTypes().FirstOrDefault(o => o.Name == plugin.Type)
                                        : assemblies[plugin.AssemblyName].GetExportedTypes().FirstOrDefault(o => o.FullName == plugin.Type);
                if (type == null)
                {
                    throw new InvalidOperationException($"Type {plugin.Type} was not found inside assembly {plugin.AssemblyName}. Hint: Make sure that the type is public.");
                }
                var pluginInstance = Activator.CreateInstance(type) as IPlugin;
                if (pluginInstance == null)
                {
                    throw new InvalidOperationException($"Type {plugin.Type} from assembly {plugin.AssemblyName} does not implement IPlugin interaface");
                }
                projectConfiguration.RegisterPlugin(pluginInstance);
            }
        }
コード例 #4
0
        private static void Configure(AsyncGenerator configuration, Analyzation config, IFluentProjectAnalyzeConfiguration fluentConfig)
        {
            if (config.CallForwarding.HasValue)
            {
                fluentConfig.CallForwarding(config.CallForwarding.Value);
            }
            if (config.PropertyConversion.HasValue)
            {
                fluentConfig.PropertyConversion(config.PropertyConversion.Value);
            }
            if (config.ScanMethodBody.HasValue)
            {
                fluentConfig.ScanMethodBody(config.ScanMethodBody.Value);
            }
            if (config.ScanForMissingAsyncMembers.Any())
            {
                fluentConfig.ScanForMissingAsyncMembers(CreateTypePredicate(configuration, config.ScanForMissingAsyncMembers));
            }
            if (config.CancellationTokens.IsEnabled)
            {
                fluentConfig.CancellationTokens(o => Configure(configuration, config.CancellationTokens, o));
            }
            fluentConfig.AsyncExtensionMethods(o => Configure(config.AsyncExtensionMethods, o));
            fluentConfig.Diagnostics(o => Configure(configuration, config.Diagnostics, o));
            fluentConfig.ExceptionHandling(o => Configure(configuration, config.ExceptionHandling, o));

            if (config.IgnoreDocuments.Any())
            {
                fluentConfig.DocumentSelection(CreateDocumentPredicate(config.IgnoreDocuments, false));
            }
            if (config.MethodConversion.Any())
            {
                fluentConfig.MethodConversion(CreateMethodConversionFunction(configuration, config.MethodConversion));
            }
            if (config.PreserveReturnType.Any())
            {
                fluentConfig.PreserveReturnType(CreateMethodPredicate(configuration, config.PreserveReturnType, true));
            }
            if (config.AlwaysAwait.Any())
            {
                fluentConfig.AlwaysAwait(CreateMethodPredicate(configuration, config.AlwaysAwait, true));
            }
            if (config.IgnoreSearchForAsyncCounterparts.Any())
            {
                fluentConfig.SearchForAsyncCounterparts(CreateMethodPredicate(configuration, config.IgnoreSearchForAsyncCounterparts, false));
            }
            if (config.IgnoreAsyncCounterparts.Any())
            {
                fluentConfig.IgnoreAsyncCounterparts(CreateMethodPredicate(configuration, config.IgnoreAsyncCounterparts, true));
            }
            if (config.IgnoreSearchForMethodReferences.Any())
            {
                fluentConfig.SearchForMethodReferences(CreateMethodPredicate(configuration, config.IgnoreSearchForMethodReferences, false));
            }
            if (config.TypeConversion.Any())
            {
                fluentConfig.TypeConversion(CreateTypeConversionFunction(configuration, config.TypeConversion));
            }
        }
コード例 #5
0
 private static void Configure(AsyncGenerator configuration, ExceptionHandling config, IFluentProjectExceptionHandlingConfiguration fluentConfig)
 {
     if (config.CatchPropertyGetterCalls.Any())
     {
         fluentConfig.CatchPropertyGetterCalls(CreateMethodPredicateFunction(configuration, config.CatchPropertyGetterCalls, false));
     }
     if (config.CatchMethodBody.Any())
     {
         fluentConfig.CatchMethodBody(CreateMethodNullablePredicate(configuration, config.CatchMethodBody));
     }
 }
コード例 #6
0
        private static Predicate <IMethodSymbol> CreateMethodPredicateFunction(AsyncGenerator globalConfig, IList <MethodPredicateFilter> filters, bool defaultResult)
        {
            var rules = globalConfig.MethodRules.ToDictionary(o => o.Name, o => o.Filters);

            return(symbol =>
            {
                foreach (var filter in filters)
                {
                    if (CanApply(symbol, filter, rules))
                    {
                        return filter.Result;
                    }
                }
                return defaultResult;                 // Default value
            });
        }
コード例 #7
0
        private static Predicate <INamedTypeSymbol> CreateTypePredicate(AsyncGenerator globalConfig, IList <TypeFilter> filters)
        {
            var rules = globalConfig.TypeRules.ToDictionary(o => o.Name, o => o.Filters);

            return(symbol =>
            {
                foreach (var filter in filters)
                {
                    if (CanApply(symbol, filter, rules))
                    {
                        return true;
                    }
                }
                return false;
            });
        }
コード例 #8
0
        private static Predicate <IMethodSymbol> CreateMethodPredicate(AsyncGenerator globalConfig, IList <MethodFilter> filters, bool validValue)
        {
            var rules = globalConfig.MethodRules.ToDictionary(o => o.Name, o => o.Filters);

            return(symbol =>
            {
                foreach (var filter in filters)
                {
                    if (CanApply(symbol, filter, rules))
                    {
                        return validValue;
                    }
                }
                return !validValue;
            });
        }
コード例 #9
0
        private static Func <IMethodSymbol, string> CreateMethodContentFunction(AsyncGenerator globalConfig, List <MethodContentFilter> filters)
        {
            var rules = globalConfig.MethodRules.ToDictionary(o => o.Name, o => o.Filters);

            return(symbol =>
            {
                foreach (var filter in filters)
                {
                    if (CanApply(symbol, filter, rules))
                    {
                        return filter.Content;
                    }
                }
                return null;
            });
        }
コード例 #10
0
        private static Func <IMethodSymbol, bool?> CreateMethodNullablePredicate(AsyncGenerator globalConfig, IList <MethodPredicateFilter> filters)
        {
            var rules = globalConfig.MethodRules.ToDictionary(o => o.Name, o => o.Filters);

            return(symbol =>
            {
                foreach (var filter in filters)
                {
                    if (CanApply(symbol, filter, rules))
                    {
                        return filter.Result;
                    }
                }
                return null;
            });
        }
コード例 #11
0
 private static void Configure(AsyncGenerator configuration, CancellationTokens config, IFluentProjectCancellationTokenConfiguration fluentConfig)
 {
     if (config.Guards.HasValue)
     {
         fluentConfig.Guards(config.Guards.Value);
     }
     if (config.MethodParameter.Any())
     {
         fluentConfig.ParameterGeneration(CreateParameterGenerationFunction(configuration, config.MethodParameter));
     }
     if (config.WithoutCancellationToken.Any() || config.RequiresCancellationToken.Any())
     {
         fluentConfig.RequiresCancellationToken(CreateMethodNullablePredicate(configuration,
                                                                              config.WithoutCancellationToken, config.RequiresCancellationToken));
     }
 }
コード例 #12
0
 private static void Configure(AsyncGenerator configuration, Diagnostics config, IFluentProjectDiagnosticsConfiguration fluentConfig)
 {
     if (config.Disable == true)
     {
         fluentConfig.Disable();
     }
     if (config.DiagnoseDocument.Any())
     {
         fluentConfig.DiagnoseDocument(CreateDocumentPredicateFunction(config.DiagnoseDocument, true));
     }
     if (config.DiagnoseType.Any())
     {
         fluentConfig.DiagnoseType(CreateTypePredicateFunction(configuration, config.DiagnoseType, true));
     }
     if (config.DiagnoseMethod.Any())
     {
         fluentConfig.DiagnoseMethod(CreateMethodPredicateFunction(configuration, config.DiagnoseMethod, true));
     }
 }
コード例 #13
0
        private static void Configure(AsyncGenerator configuration, DocumentationComments config, IFluentProjectDocumentationCommentConfiguration fluentConfig)
        {
            if (config.AddOrReplacePartialTypeComments.Any())
            {
                fluentConfig.AddOrReplacePartialTypeComments(CreateTypeContentFunction(configuration, config.AddOrReplacePartialTypeComments));
            }
            if (config.RemovePartialTypeComments.Any())
            {
                fluentConfig.RemovePartialTypeComments(CreateTypePredicate(configuration, config.RemovePartialTypeComments));
            }

            if (config.AddOrReplaceNewTypeComments.Any())
            {
                fluentConfig.AddOrReplaceNewTypeComments(CreateTypeContentFunction(configuration, config.AddOrReplaceNewTypeComments));
            }
            if (config.RemoveNewTypeComments.Any())
            {
                fluentConfig.RemoveNewTypeComments(CreateTypePredicate(configuration, config.RemoveNewTypeComments));
            }

            if (config.AddOrReplaceMethodRemarks.Any())
            {
                fluentConfig.AddOrReplaceMethodRemarks(CreateMethodContentFunction(configuration, config.AddOrReplaceMethodRemarks));
            }
            if (config.RemoveMethodRemarks.Any())
            {
                fluentConfig.RemoveMethodRemarks(CreateMethodPredicate(configuration, config.RemoveMethodRemarks, true));
            }

            if (config.AddOrReplaceMethodSummary.Any())
            {
                fluentConfig.AddOrReplaceMethodSummary(CreateMethodContentFunction(configuration, config.AddOrReplaceMethodSummary));
            }
            if (config.RemoveMethodSummary.Any())
            {
                fluentConfig.RemoveMethodSummary(CreateMethodPredicate(configuration, config.RemoveMethodSummary, true));
            }
        }
コード例 #14
0
 private static void Configure(AsyncGenerator configuration, Transformation config, IFluentProjectTransformConfiguration fluentConfig)
 {
     if (config.LocalFunctions.HasValue)
     {
         fluentConfig.LocalFunctions(config.LocalFunctions.Value);
     }
     if (!string.IsNullOrEmpty(config.AsyncFolder))
     {
         fluentConfig.AsyncFolder(config.AsyncFolder);
     }
     if (config.ConfigureAwaitArgument.HasValue)
     {
         fluentConfig.ConfigureAwaitArgument(config.ConfigureAwaitArgument.Value);
     }
     if (config.Disable == true)
     {
         fluentConfig.Disable();
     }
     if (!string.IsNullOrEmpty(config.AsyncLock.Type))
     {
         fluentConfig.AsyncLock(config.AsyncLock.Type, config.AsyncLock.MethodName);
     }
     fluentConfig.DocumentationComments(o => Configure(configuration, config.DocumentationComments, o));
 }
コード例 #15
0
        private static Func <IMethodSymbol, MethodConversion> CreateMethodConversionFunction(AsyncGenerator globalConfig, IList <MethodConversionFilter> filters)
        {
            var rules = globalConfig.MethodRules.ToDictionary(o => o.Name, o => o.Filters);

            return(symbol =>
            {
                foreach (var filter in filters)
                {
                    if (CanApply(symbol, filter, rules))
                    {
                        return filter.Conversion;
                    }
                }
                return MethodConversion.Unknown;                 // Default value
            });
        }
コード例 #16
0
        private static Func <INamedTypeSymbol, TypeConversion> CreateTypeConversionFunction(AsyncGenerator globalConfig, IList <TypeConversionFilter> filters)
        {
            var rules = globalConfig.TypeRules.ToDictionary(o => o.Name, o => o.Filters);

            return(symbol =>
            {
                foreach (var filter in filters)
                {
                    if (CanApply(symbol, filter, rules))
                    {
                        return filter.Conversion;
                    }
                }
                return TypeConversion.Unknown;
            });
        }
コード例 #17
0
        private static Func <IMethodSymbolInfo, MethodCancellationToken> CreateParameterGenerationFunction(AsyncGenerator globalConfig, IList <MethodCancellationTokenFilter> filters)
        {
            var rules = globalConfig.MethodRules.ToDictionary(o => o.Name, o => o.Filters);

            return(symbol =>
            {
                foreach (var filter in filters)
                {
                    if (!string.IsNullOrEmpty(filter.AnyInterfaceRule) && !symbol.ImplementedInterfaces.Any(i => rules[filter.AnyInterfaceRule].Any(o => CanApply(i, o, rules))))
                    {
                        continue;
                    }
                    if (CanApply(symbol.Symbol, filter, rules))
                    {
                        return filter.Parameter;
                    }
                }
                return MethodCancellationToken.Optional;
            });
        }