8721170550

Committed 17 Apr 2024 11:35AM UTC coverage: 54.552% (-0.2%) from 54.745%

Build # 8721170550

Build Type

Pull #561

github

Committed by

web-flow

Commit Message

Merge 6e3264ecc into 83aa54cf2

Pull Request Pull Request #561: Closes #560 Add option to delete unused files

Run Details

557 of 1109 branches covered (50.23%)

Branch coverage included in aggregate %.

2 of 13 new or added lines in 2 files covered. (15.38%)

1 existing line in 1 file now uncovered.

1564 of 2779 relevant lines covered (56.28%)

70.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/EntityFrameworkCore.Generator.Core/OptionMapper.cs

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

using EntityFrameworkCore.Generator.Options;
using EntityFrameworkCore.Generator.Serialization;

using Microsoft.CodeAnalysis.Options;

using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace EntityFrameworkCore.Generator;

public static class OptionMapper
{
    public static GeneratorOptions Map(GeneratorModel generator)
    {
        var options = new GeneratorOptions();
        options.Variables.ShouldEvaluate = false;

        MapProject(options.Project, generator.Project);
        MapDatabase(options.Database, generator.Database);
        MapData(options.Data, generator.Data);
        MapModel(options.Model, generator.Model);
        MapScript(options.Script, generator.Script);

        options.Variables.ShouldEvaluate = true;

        return options;
    }

    private static void MapScript(ScriptOptions option, ScriptModel script)
    {
        if (script == null)
            return;

        MapList(option.Context, script.Context, (template) =>
        {
            var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Context{option.Context.Count:0000}");
            return MapTemplate(option.Variables, template, prefix);
        });

        MapList(option.Entity, script.Entity, (template) =>
        {
            var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Entity{option.Entity.Count:0000}");
            return MapTemplate(option.Variables, template, prefix);
        });

        MapList(option.Model, script.Model, (template) =>
        {
            var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Model{option.Entity.Count:0000}");
            return MapTemplate(option.Variables, template, prefix);
        });
    }

    private static void MapModel(ModelOptions option, ViewModel model)
    {
        MapShared(option.Shared, model.Shared);
        MapRead(option.Read, model.Read);
        MapCreate(option.Create, model.Create);
        MapUpdate(option.Update, model.Update);
        MapMapper(option.Mapper, model.Mapper);
        MapValidator(option.Validator, model.Validator);
    }

    private static void MapClassBase(ClassOptionsBase option, ClassBase classBase)
    {
        option.Namespace = classBase.Namespace;
        option.Directory = classBase.Directory;
        option.Document = classBase.Document;
        option.Name = classBase.Name;
        option.BaseClass = classBase.BaseClass;
        option.Attributes = classBase.Attributes;
    }

    private static void MapModelBase(ModelOptionsBase option, ModelBase modelBase)
    {
        MapClassBase(option, modelBase);

        option.Generate = modelBase.Generate;

        MapSelection(option.Include, modelBase.Include);
        MapSelection(option.Exclude, modelBase.Exclude);

    }

    private static void MapValidator(ValidatorClassOptions option, ValidatorClass validator)
    {
        MapClassBase(option, validator);

        option.Generate = validator.Generate;
    }

    private static void MapMapper(MapperClassOptions option, MapperClass mapper)
    {
        MapClassBase(option, mapper);

        option.Generate = mapper.Generate;
    }

    private static void MapUpdate(UpdateModelOptions option, UpdateModel update)
    {
        MapModelBase(option, update);
    }

    private static void MapCreate(CreateModelOptions option, CreateModel create)
    {
        MapModelBase(option, create);
    }

    private static void MapRead(ReadModelOptions option, ReadModel read)
    {
        MapModelBase(option, read);
    }

    private static void MapShared(SharedModelOptions option, SharedModel shared)
    {
        option.Namespace = shared.Namespace;
        option.Directory = shared.Directory;

        MapSelection(option.Include, shared.Include);
        MapSelection(option.Exclude, shared.Exclude);
    }

    private static void MapData(DataOptions option, DataModel data)
    {
        MapContext(option.Context, data.Context);
        MapEntity(option.Entity, data.Entity);
        MapMapping(option.Mapping, data.Mapping);
        MapQuery(option.Query, data.Query);
    }

    private static void MapQuery(QueryExtensionOptions option, QueryExtension query)
    {
        MapClassBase(option, query);

        option.Generate = query.Generate;
        option.IndexPrefix = query.IndexPrefix;
        option.UniquePrefix = query.UniquePrefix;
    }

    private static void MapMapping(MappingClassOptions option, MappingClass mapping)
    {
        MapClassBase(option, mapping);

        option.Temporal = mapping.Temporal;
        option.RowVersion = mapping.RowVersion;
        option.DeleteUnusedFiles = mapping.DeleteUnusedFiles;
    }

    private static void MapEntity(EntityClassOptions option, EntityClass entity)
    {
        MapClassBase(option, entity);

        option.EntityNaming = entity.EntityNaming;
        option.RelationshipNaming = entity.RelationshipNaming;
        option.PrefixWithSchemaName = entity.PrefixWithSchemaName;
        option.DeleteUnusedFiles = entity.DeleteUnusedFiles;

        MapSelection(option.Renaming, entity.Renaming);
    }

    private static void MapSelection(SelectionOptions option, SelectionModel selection)
    {
        if (selection == null)
            return;

        MapList(option.Entities, selection.Entities, (match) =>
        {
            var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Entity{option.Entities.Count:0000}");
            return MapMatch(option.Variables, match, prefix);
        });

        MapList(option.Properties, selection.Properties, (match) =>
        {
            var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Property{option.Properties.Count:0000}");
            return MapMatch(option.Variables, match, prefix);
        });
    }

    private static void MapContext(ContextClassOptions option, ContextClass context)
    {
        MapClassBase(option, context);

        option.PropertyNaming = context.PropertyNaming;
    }

    private static void MapDatabase(DatabaseOptions option, DatabaseModel database)
    {
        option.Provider = database.Provider;
        option.ConnectionString = database.ConnectionString;
        option.ConnectionName = database.ConnectionName;
        option.UserSecretsId = database.UserSecretsId;
        option.TableNaming = database.TableNaming;

        MapList(option.Tables, database.Tables);
        MapList(option.Schemas, database.Schemas);
        MapList(option.Exclude, database.Exclude, (match) =>
        {
            var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Exclude{option.Exclude.Count:0000}");
            return MapMatch(option.Variables, match, prefix);
        });
    }

    private static void MapProject(ProjectOptions option, ProjectModel project)
    {
        option.Namespace = project.Namespace;
        option.Directory = project.Directory;
        option.Nullable = project.Nullable;
        option.FileScopedNamespace = project.FileScopedNamespace;
    }


    private static void MapList<T>(IList<T> targetList, IList<T> sourceList)
    {
        if (!(sourceList?.Count > 0))
            return;

        foreach (var source in sourceList)
            targetList.Add(source);
    }

    private static void MapList<TTarget, TSource>(IList<TTarget> targetList, IList<TSource> sourceList, Func<TSource, TTarget> factory)
    {
        if (sourceList == null || sourceList.Count == 0)
            return;

        foreach (var source in sourceList)
        {
            var target = factory(source);
            targetList.Add(target);
        }
    }

    private static MatchOptions MapMatch(VariableDictionary variables, MatchModel match, string prefix)
    {
        return new MatchOptions(variables, prefix)
        {
            Exact = match.Exact,
            Expression = match.Expression
        };
    }

    private static TemplateOptions MapTemplate(VariableDictionary variables, TemplateModel template, string prefix)
    {
        var option = new TemplateOptions(variables, prefix)
        {
            TemplatePath = template.TemplatePath,
            FileName = template.FileName,
            Namespace = template.Namespace,
            BaseClass = template.BaseClass,
            Directory = template.Directory,
            Overwrite = template.Overwrite,
            Merge = template.Merge,
        };

        if (template.Parameters == null || template.Parameters.Count == 0)
            return option;

        foreach (var paremeter in template.Parameters)
            option.Parameters[paremeter.Key] = paremeter.Value;

        return option;
    }

}

1	using System;
2	using System.Collections.Generic;
3	using System.ComponentModel.DataAnnotations;
4
5	using EntityFrameworkCore.Generator.Options;
6	using EntityFrameworkCore.Generator.Serialization;
7
8	using Microsoft.CodeAnalysis.Options;
9
10	using static Microsoft.EntityFrameworkCore.DbLoggerCategory;
11
12	namespace EntityFrameworkCore.Generator;
13
14	public static class OptionMapper
15	{
16	public static GeneratorOptions Map(GeneratorModel generator)
17	{
18	var options = new GeneratorOptions();	×
19	options.Variables.ShouldEvaluate = false;	×
20
21	MapProject(options.Project, generator.Project);	×
22	MapDatabase(options.Database, generator.Database);	×
23	MapData(options.Data, generator.Data);	×
24	MapModel(options.Model, generator.Model);	×
25	MapScript(options.Script, generator.Script);	×
26
27	options.Variables.ShouldEvaluate = true;	×
28
29	return options;	×
30	}
31
32	private static void MapScript(ScriptOptions option, ScriptModel script)
33	{
34	if (script == null)	×
35	return;	×
36
37	MapList(option.Context, script.Context, (template) =>	×
38	{	×
39	var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Context{option.Context.Count:0000}");	×
40	return MapTemplate(option.Variables, template, prefix);	×
41	});	×
42
43	MapList(option.Entity, script.Entity, (template) =>	×
44	{	×
45	var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Entity{option.Entity.Count:0000}");	×
46	return MapTemplate(option.Variables, template, prefix);	×
47	});	×
48
49	MapList(option.Model, script.Model, (template) =>	×
50	{	×
51	var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Model{option.Entity.Count:0000}");	×
52	return MapTemplate(option.Variables, template, prefix);	×
53	});	×
54	}	×
55
56	private static void MapModel(ModelOptions option, ViewModel model)
57	{
58	MapShared(option.Shared, model.Shared);	×
59	MapRead(option.Read, model.Read);	×
60	MapCreate(option.Create, model.Create);	×
61	MapUpdate(option.Update, model.Update);	×
62	MapMapper(option.Mapper, model.Mapper);	×
63	MapValidator(option.Validator, model.Validator);	×
64	}	×
65
66	private static void MapClassBase(ClassOptionsBase option, ClassBase classBase)
67	{
68	option.Namespace = classBase.Namespace;	×
69	option.Directory = classBase.Directory;	×
70	option.Document = classBase.Document;	×
71	option.Name = classBase.Name;	×
72	option.BaseClass = classBase.BaseClass;	×
73	option.Attributes = classBase.Attributes;	×
74	}	×
75
76	private static void MapModelBase(ModelOptionsBase option, ModelBase modelBase)
77	{
78	MapClassBase(option, modelBase);	×
79
80	option.Generate = modelBase.Generate;	×
81
82	MapSelection(option.Include, modelBase.Include);	×
83	MapSelection(option.Exclude, modelBase.Exclude);	×
84
85	}	×
86
87	private static void MapValidator(ValidatorClassOptions option, ValidatorClass validator)
88	{
89	MapClassBase(option, validator);	×
90
91	option.Generate = validator.Generate;	×
92	}	×
93
94	private static void MapMapper(MapperClassOptions option, MapperClass mapper)
95	{
96	MapClassBase(option, mapper);	×
97
98	option.Generate = mapper.Generate;	×
99	}	×
100
101	private static void MapUpdate(UpdateModelOptions option, UpdateModel update)
102	{
103	MapModelBase(option, update);	×
104	}	×
105
106	private static void MapCreate(CreateModelOptions option, CreateModel create)
107	{
108	MapModelBase(option, create);	×
109	}	×
110
111	private static void MapRead(ReadModelOptions option, ReadModel read)
112	{
113	MapModelBase(option, read);	×
114	}	×
115
116	private static void MapShared(SharedModelOptions option, SharedModel shared)
117	{
118	option.Namespace = shared.Namespace;	×
119	option.Directory = shared.Directory;	×
120
121	MapSelection(option.Include, shared.Include);	×
122	MapSelection(option.Exclude, shared.Exclude);	×
123	}	×
124
125	private static void MapData(DataOptions option, DataModel data)
126	{
127	MapContext(option.Context, data.Context);	×
128	MapEntity(option.Entity, data.Entity);	×
129	MapMapping(option.Mapping, data.Mapping);	×
130	MapQuery(option.Query, data.Query);	×
131	}	×
132
133	private static void MapQuery(QueryExtensionOptions option, QueryExtension query)
134	{
135	MapClassBase(option, query);	×
136
137	option.Generate = query.Generate;	×
138	option.IndexPrefix = query.IndexPrefix;	×
139	option.UniquePrefix = query.UniquePrefix;	×
140	}	×
141
142	private static void MapMapping(MappingClassOptions option, MappingClass mapping)
143	{
144	MapClassBase(option, mapping);	×
145
146	option.Temporal = mapping.Temporal;	×
147	option.RowVersion = mapping.RowVersion;	×
NEW 148	option.DeleteUnusedFiles = mapping.DeleteUnusedFiles;	×
UNCOV 149	}	×
150
151	private static void MapEntity(EntityClassOptions option, EntityClass entity)
152	{
153	MapClassBase(option, entity);	×
154
155	option.EntityNaming = entity.EntityNaming;	×
156	option.RelationshipNaming = entity.RelationshipNaming;	×
157	option.PrefixWithSchemaName = entity.PrefixWithSchemaName;	×
NEW 158	option.DeleteUnusedFiles = entity.DeleteUnusedFiles;	×
159
160	MapSelection(option.Renaming, entity.Renaming);	×
161	}	×
162
163	private static void MapSelection(SelectionOptions option, SelectionModel selection)
164	{
165	if (selection == null)	×
166	return;	×
167
168	MapList(option.Entities, selection.Entities, (match) =>	×
169	{	×
170	var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Entity{option.Entities.Count:0000}");	×
171	return MapMatch(option.Variables, match, prefix);	×
172	});	×
173
174	MapList(option.Properties, selection.Properties, (match) =>	×
175	{	×
176	var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Property{option.Properties.Count:0000}");	×
177	return MapMatch(option.Variables, match, prefix);	×
178	});	×
179	}	×
180
181	private static void MapContext(ContextClassOptions option, ContextClass context)
182	{
183	MapClassBase(option, context);	×
184
185	option.PropertyNaming = context.PropertyNaming;	×
186	}	×
187
188	private static void MapDatabase(DatabaseOptions option, DatabaseModel database)
189	{
190	option.Provider = database.Provider;	×
191	option.ConnectionString = database.ConnectionString;	×
192	option.ConnectionName = database.ConnectionName;	×
193	option.UserSecretsId = database.UserSecretsId;	×
194	option.TableNaming = database.TableNaming;	×
195
196	MapList(option.Tables, database.Tables);	×
197	MapList(option.Schemas, database.Schemas);	×
198	MapList(option.Exclude, database.Exclude, (match) =>	×
199	{	×
200	var prefix = OptionsBase.AppendPrefix(option.Prefix, $"Exclude{option.Exclude.Count:0000}");	×
201	return MapMatch(option.Variables, match, prefix);	×
202	});	×
203	}	×
204
205	private static void MapProject(ProjectOptions option, ProjectModel project)
206	{
207	option.Namespace = project.Namespace;	×
208	option.Directory = project.Directory;	×
209	option.Nullable = project.Nullable;	×
210	option.FileScopedNamespace = project.FileScopedNamespace;	×
211	}	×
212
213
214	private static void MapList<T>(IList<T> targetList, IList<T> sourceList)
215	{
216	if (!(sourceList?.Count > 0))	×
217	return;	×
218
219	foreach (var source in sourceList)	×
220	targetList.Add(source);	×
221	}	×
222
223	private static void MapList<TTarget, TSource>(IList<TTarget> targetList, IList<TSource> sourceList, Func<TSource, TTarget> factory)
224	{
225	if (sourceList == null \|\| sourceList.Count == 0)	×
226	return;	×
227
228	foreach (var source in sourceList)	×
229	{
230	var target = factory(source);	×
231	targetList.Add(target);	×
232	}
233	}	×
234
235	private static MatchOptions MapMatch(VariableDictionary variables, MatchModel match, string prefix)
236	{
237	return new MatchOptions(variables, prefix)	×
238	{	×
239	Exact = match.Exact,	×
240	Expression = match.Expression	×
241	};	×
242	}
243
244	private static TemplateOptions MapTemplate(VariableDictionary variables, TemplateModel template, string prefix)
245	{
246	var option = new TemplateOptions(variables, prefix)	×
247	{	×
248	TemplatePath = template.TemplatePath,	×
249	FileName = template.FileName,	×
250	Namespace = template.Namespace,	×
251	BaseClass = template.BaseClass,	×
252	Directory = template.Directory,	×
253	Overwrite = template.Overwrite,	×
254	Merge = template.Merge,	×
255	};	×
256
257	if (template.Parameters == null \|\| template.Parameters.Count == 0)	×
258	return option;	×
259
260	foreach (var paremeter in template.Parameters)	×
261	option.Parameters[paremeter.Key] = paremeter.Value;	×
262
263	return option;	×
264	}
265
266	}

loresoft / EntityFrameworkCore.Generator / 8721170550

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous