9606887052

Committed 21 Jun 2024 01:35AM UTC coverage: 88.335% (-0.5%) from 88.829%

Build # 9606887052

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Merge pull request #254 from JaCraig/IEnumerable-bug

fix: Merging in bug fix for IEnumerable bug

Run Details

534 of 838 branches covered (63.72%)

Branch coverage included in aggregate %.

81 of 100 new or added lines in 4 files covered. (81.0%)

12 existing lines in 4 files now uncovered.

3828 of 4100 relevant lines covered (93.37%)

56783.19 hits per line

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

82.14

/src/Mirage/Manager/Builder.cs

﻿/*
Copyright 2017 James Craig

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

using BigBook;
using Mirage.Generators;
using Mirage.Generators.Default;
using Mirage.Interfaces;
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace Mirage.Manager
{
    /// <summary>
    /// Builder for getting the generators
    /// </summary>
    public class Builder
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Builder"/> class.
        /// </summary>
        /// <param name="generators">The generators.</param>
        public Builder(IEnumerable<IGenerator> generators)
        {
            Generators = new ConcurrentDictionary<Type, IGenerator>();
            Assembly MirageAssembly = typeof(Builder).Assembly;
            foreach (IGenerator? Generator in generators.Where(x => x.GetType().Assembly != MirageAssembly))
            {
                Generators.Add(Generator.TypeGenerated, Generator);
            }
            foreach (IGenerator? Generator in generators.Where(x => x.Default))
            {
                if (!Generators.ContainsKey(Generator.TypeGenerated))
                {
                    Generators.Add(Generator.TypeGenerated, Generator);
                }
            }
        }

        /// <summary>
        /// Gets the generators.
        /// </summary>
        /// <value>The generators.</value>
        public IDictionary<Type, IGenerator> Generators { get; }

        /// <summary>
        /// Gets the generator specified
        /// </summary>
        /// <typeparam name="T">The type to generate</typeparam>
        /// <returns>The generator specified</returns>
        public IGenerator<T>? GetGenerator<T>() => GetGenerator(typeof(T)) as IGenerator<T>;

        /// <summary>
        /// Gets the generator specified
        /// </summary>
        /// <param name="classType">Type of the class.</param>
        /// <returns>The generator specified</returns>
        public IGenerator? GetGenerator(Type classType)
        {
            if (classType is null)
                return null;
            if (Generators.TryGetValue(classType, out IGenerator? Generator))
                return Generator;
            TypeInfo TypeGeneratedInfo = classType.GetTypeInfo();
            if (TypeGeneratedInfo.IsEnum)
                return new EnumGeneratorAttribute(classType);
            if (TypeGeneratedInfo.IsArray)
                return new ArrayGeneratorAttribute(classType.GetElementType(), 1, 100);
            _ = TypeGeneratedInfo.GetInterfaces();

            if (IsDictionary(TypeGeneratedInfo, out Type? Arg1, out Type? Arg2))
                return new DictionaryGeneratorAttribute(Arg1, Arg2, 1, 100);
            if (IsList(TypeGeneratedInfo, out Type? ListArg))
                return new ListGeneratorAttribute(ListArg, 1, 100);
            if (IsIEnumerable(TypeGeneratedInfo, out Type? IEnumerableArg))
                return new IEnumerableGeneratorAttribute(IEnumerableArg, 1, 100);

            if (TypeGeneratedInfo.IsClass && TypeGeneratedInfo.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IList<>)))
                return (IGenerator?)new ClassListGeneratorAttribute(classType);

            if (TypeGeneratedInfo.IsClass || (TypeGeneratedInfo.IsValueType && !TypeGeneratedInfo.IsPrimitive))
                return (IGenerator?)new ClassGeneratorAttribute(classType);

            return null;
        }

        /// <summary>
        /// Determines if the class is a dictionary
        /// </summary>
        /// <param name="classType">Type of the class.</param>
        /// <param name="argument1">The argument1.</param>
        /// <param name="argument2">The argument2.</param>
        /// <returns>True if it is a dictionary, false otherwise</returns>
        private static bool IsDictionary(Type classType, out Type? argument1, out Type? argument2)
        {
            argument1 = null;
            argument2 = null;
            if (classType == typeof(IDictionary))
            {
                argument1 = typeof(string);
                argument2 = typeof(string);
                return true;
            }
            if (!classType.IsGenericType)
                return false;

            Type[] GenericArguments = classType.GetGenericArguments();
            if (GenericArguments.Length < 2)
                return false;

            argument1 = GenericArguments[0];
            argument2 = GenericArguments[1];
            return classType.IsAssignableTo(typeof(IDictionary<,>).MakeGenericType(GenericArguments[0], GenericArguments[1]));
        }

        /// <summary>
        /// Determines if the class is an IEnumerable
        /// </summary>
        /// <param name="classType">Type of the class.</param>
        /// <param name="arg">The argument.</param>
        /// <returns>True if it is an IEnumerable, false otherwise</returns>
        private static bool IsIEnumerable(Type classType, out Type? arg)
        {
            arg = null;
            if (classType == typeof(IEnumerable))
            {
                arg = typeof(string);
                return true;
            }
            if (!classType.IsGenericType)
                return false;

            Type[] GenericArguments = classType.GetGenericArguments();
            arg = GenericArguments[0];
            return classType.IsAssignableTo(typeof(IEnumerable<>).MakeGenericType(GenericArguments[0]));
        }

        /// <summary>
        /// Determines if the class is a list
        /// </summary>
        /// <param name="classType">Type of the class.</param>
        /// <param name="arg">The argument.</param>
        /// <returns>True if it is a list, false otherwise</returns>
        private static bool IsList(Type classType, out Type? arg)
        {
            arg = null;
            if (classType == typeof(IList))
            {
                arg = typeof(string);
                return true;
            }
            if (!classType.IsGenericType)
                return false;

            Type[] GenericArguments = classType.GetGenericArguments();
            arg = GenericArguments[0];
            return classType.IsAssignableTo(typeof(IList<>).MakeGenericType(GenericArguments[0]));
        }
    }
}

1	/*
2	Copyright 2017 James Craig
3
4	Licensed under the Apache License, Version 2.0 (the "License");
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	http://www.apache.org/licenses/LICENSE-2.0
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	using BigBook;
18	using Mirage.Generators;
19	using Mirage.Generators.Default;
20	using Mirage.Interfaces;
21	using System;
22	using System.Collections;
23	using System.Collections.Concurrent;
24	using System.Collections.Generic;
25	using System.Linq;
26	using System.Reflection;
27
28	namespace Mirage.Manager
29	{
30	/// <summary>
31	/// Builder for getting the generators
32	/// </summary>
33	public class Builder
34	{
35	/// <summary>
36	/// Initializes a new instance of the <see cref="Builder"/> class.
37	/// </summary>
38	/// <param name="generators">The generators.</param>
39	public Builder(IEnumerable<IGenerator> generators)	1✔
40	{
41	Generators = new ConcurrentDictionary<Type, IGenerator>();	1✔
42	Assembly MirageAssembly = typeof(Builder).Assembly;	1✔
43	foreach (IGenerator? Generator in generators.Where(x => x.GetType().Assembly != MirageAssembly))	76!
44	{
45	Generators.Add(Generator.TypeGenerated, Generator);	×
46	}
47	foreach (IGenerator? Generator in generators.Where(x => x.Default))	166✔
48	{
49	if (!Generators.ContainsKey(Generator.TypeGenerated))	45✔
50	{
51	Generators.Add(Generator.TypeGenerated, Generator);	35✔
52	}
53	}
54	}	1✔
55
56	/// <summary>
57	/// Gets the generators.
58	/// </summary>
59	/// <value>The generators.</value>
60	public IDictionary<Type, IGenerator> Generators { get; }	15,151,520✔
61
62	/// <summary>
63	/// Gets the generator specified
64	/// </summary>
65	/// <typeparam name="T">The type to generate</typeparam>
66	/// <returns>The generator specified</returns>
67	public IGenerator<T>? GetGenerator<T>() => GetGenerator(typeof(T)) as IGenerator<T>;	14,671,280✔
68
69	/// <summary>
70	/// Gets the generator specified
71	/// </summary>
72	/// <param name="classType">Type of the class.</param>
73	/// <returns>The generator specified</returns>
74	public IGenerator? GetGenerator(Type classType)
75	{
76	if (classType is null)	15,151,440!
77	return null;	×
78	if (Generators.TryGetValue(classType, out IGenerator? Generator))	15,151,440✔
79	return Generator;	14,765,158✔
80	TypeInfo TypeGeneratedInfo = classType.GetTypeInfo();	386,282✔
81	if (TypeGeneratedInfo.IsEnum)	386,282!
82	return new EnumGeneratorAttribute(classType);	×
83	if (TypeGeneratedInfo.IsArray)	386,282✔
84	return new ArrayGeneratorAttribute(classType.GetElementType(), 1, 100);	1✔
85	_ = TypeGeneratedInfo.GetInterfaces();	386,281✔
86
87	if (IsDictionary(TypeGeneratedInfo, out Type? Arg1, out Type? Arg2))	386,281✔
88	return new DictionaryGeneratorAttribute(Arg1, Arg2, 1, 100);	1✔
89	if (IsList(TypeGeneratedInfo, out Type? ListArg))	386,280✔
90	return new ListGeneratorAttribute(ListArg, 1, 100);	271✔
91	if (IsIEnumerable(TypeGeneratedInfo, out Type? IEnumerableArg))	386,009✔
92	return new IEnumerableGeneratorAttribute(IEnumerableArg, 1, 100);	1✔
93
94	if (TypeGeneratedInfo.IsClass && TypeGeneratedInfo.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IList<>)))	386,027!
95	return (IGenerator?)new ClassListGeneratorAttribute(classType);	19✔
96
97	if (TypeGeneratedInfo.IsClass \|\| (TypeGeneratedInfo.IsValueType && !TypeGeneratedInfo.IsPrimitive))	385,989!
98	return (IGenerator?)new ClassGeneratorAttribute(classType);	385,989✔
99
NEW 100	return null;	×
101	}
102
103	/// <summary>
104	/// Determines if the class is a dictionary
105	/// </summary>
106	/// <param name="classType">Type of the class.</param>
107	/// <param name="argument1">The argument1.</param>
108	/// <param name="argument2">The argument2.</param>
109	/// <returns>True if it is a dictionary, false otherwise</returns>
110	private static bool IsDictionary(Type classType, out Type? argument1, out Type? argument2)
111	{
112	argument1 = null;	386,281✔
113	argument2 = null;	386,281✔
114	if (classType == typeof(IDictionary))	386,281!
115	{
NEW 116	argument1 = typeof(string);	×
NEW 117	argument2 = typeof(string);	×
NEW 118	return true;	×
119	}
120	if (!classType.IsGenericType)	386,281✔
121	return false;	386,008✔
122
123	Type[] GenericArguments = classType.GetGenericArguments();	273✔
124	if (GenericArguments.Length < 2)	273✔
125	return false;	272✔
126
127	argument1 = GenericArguments[0];	1✔
128	argument2 = GenericArguments[1];	1✔
129	return classType.IsAssignableTo(typeof(IDictionary<,>).MakeGenericType(GenericArguments[0], GenericArguments[1]));	1✔
130	}
131
132	/// <summary>
133	/// Determines if the class is an IEnumerable
134	/// </summary>
135	/// <param name="classType">Type of the class.</param>
136	/// <param name="arg">The argument.</param>
137	/// <returns>True if it is an IEnumerable, false otherwise</returns>
138	private static bool IsIEnumerable(Type classType, out Type? arg)
139	{
140	arg = null;	386,009✔
141	if (classType == typeof(IEnumerable))	386,009!
142	{
NEW 143	arg = typeof(string);	×
NEW 144	return true;	×
145	}
146	if (!classType.IsGenericType)	386,009✔
147	return false;	386,008✔
148
149	Type[] GenericArguments = classType.GetGenericArguments();	1✔
150	arg = GenericArguments[0];	1✔
151	return classType.IsAssignableTo(typeof(IEnumerable<>).MakeGenericType(GenericArguments[0]));	1✔
152	}
153
154	/// <summary>
155	/// Determines if the class is a list
156	/// </summary>
157	/// <param name="classType">Type of the class.</param>
158	/// <param name="arg">The argument.</param>
159	/// <returns>True if it is a list, false otherwise</returns>
160	private static bool IsList(Type classType, out Type? arg)
161	{
162	arg = null;	386,280✔
163	if (classType == typeof(IList))	386,280!
164	{
NEW 165	arg = typeof(string);	×
NEW 166	return true;	×
167	}
168	if (!classType.IsGenericType)	386,280✔
169	return false;	386,008✔
170
171	Type[] GenericArguments = classType.GetGenericArguments();	272✔
172	arg = GenericArguments[0];	272✔
173	return classType.IsAssignableTo(typeof(IList<>).MakeGenericType(GenericArguments[0]));	272✔
174	}
175	}
176	}

JaCraig / Mirage / 9606887052

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