leeonky / test-charm-java / 296

Committed 15 Sep 2025 02:01PM UTC coverage: 74.593% (+0.4%) from 74.22%

Build # 296

Build Type

push

circleci

Committed by

leeonky

Commit Message

checking during consistency merge

Run Details

89 of 94 new or added lines in 6 files covered. (94.68%)

11 existing lines in 6 files now uncovered.

8435 of 11308 relevant lines covered (74.59%)

0.75 hits per line

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

98.57

/jfactory/src/main/java/com/github/leeonky/jfactory/JFactory.java

package com.github.leeonky.jfactory;

import com.github.leeonky.util.BeanClass;
import com.github.leeonky.util.GenericBeanClass;
import com.github.leeonky.util.PropertyWriter;
import com.github.leeonky.util.TypeReference;

import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Predicate;

import static com.github.leeonky.jfactory.DefaultBuilder.BuildFrom.SPEC;
import static com.github.leeonky.jfactory.DefaultBuilder.BuildFrom.TYPE;

public class JFactory {
    final AliasSetStore aliasSetStore = new AliasSetStore();
    private final FactorySet factorySet = new FactorySet();
    private final DataRepository dataRepository;
    private final Set<Predicate<PropertyWriter<?>>> ignoreDefaultValues = new LinkedHashSet<>();

    public JFactory() {
        dataRepository = new MemoryDataRepository();
    }

    public JFactory(DataRepository dataRepository) {
        this.dataRepository = dataRepository;
    }

    public DataRepository getDataRepository() {
        return dataRepository;
    }

    public <T> Factory<T> factory(Class<T> type) {
        return factory(BeanClass.create(type));
    }

    public <T> Factory<T> factory(BeanClass<T> type) {
        return factorySet.queryObjectFactory(type);
    }

    public <T> Builder<T> type(Class<T> type) {
        return type(BeanClass.create(type));
    }

    public <T> Builder<T> type(BeanClass<T> type) {
        return new DefaultBuilder<>(factorySet.queryObjectFactory(type), this, TYPE);
    }

    public <T> Builder<T> type(TypeReference<T> type) {
        return type(type.getType());
    }

    public <T, S extends Spec<T>> Builder<T> spec(Class<S> specClass) {
        return new DefaultBuilder<>((ObjectFactory<T>) specFactory(specClass), this, SPEC);
    }

    public <T, S extends Spec<T>> Builder<T> spec(Class<S> specClass, Consumer<S> trait) {
        return new DefaultBuilder<>(factorySet.createSpecFactory(specClass, trait), this, SPEC);
    }

    public <T, S extends Spec<T>> Builder<T[]> specs(Class<S> specClass) {
        Factory<T> specFactory = specFactory(specClass);
        Class<T[]> arrayType = (Class<T[]>) Array.newInstance(specFactory.getType().getType(), 0).getClass();
        ObjectFactory<T[]> listFactory = new ObjectFactory<>(BeanClass.create(arrayType), factorySet);
        listFactory.spec(ins -> ins.spec().property("[]").is(specClass));
        return new DefaultBuilder<>(listFactory, this, TYPE);
    }

    public <T, S extends Spec<T>, L extends List<T>> Builder<L> specs(Class<L> collectionType, Class<S> specClass) {
        Factory<T> specFactory = specFactory(specClass);
        ObjectFactory<L> listFactory = new ObjectFactory<>(GenericBeanClass.create(collectionType,
                specFactory.getType().getType()), factorySet);
        listFactory.spec(ins -> ins.spec().property("[]").is(specClass));
        return new DefaultBuilder<>(listFactory, this, TYPE);
    }

    public <T> Builder<T> spec(String... traitsAndSpec) {
        String specName = traitsAndSpec[traitsAndSpec.length - 1];
        if (specName.endsWith("[]")) {
            specName = specName.replace("[]", "");
            Factory<Object> specFactory = specFactory(specName);
            ObjectFactory<?> listFactory = new ObjectFactory<>(GenericBeanClass.create(List.class, specFactory.getType().getType()), factorySet);
            traitsAndSpec[traitsAndSpec.length - 1] = specName;
            listFactory.spec(ins -> ins.spec().property("[]").is(traitsAndSpec));
            return new DefaultBuilder(listFactory, this, TYPE);
        }
        return new DefaultBuilder<>((ObjectFactory<T>) specFactory(specName), this, SPEC)
                .traits(Arrays.copyOf(traitsAndSpec, traitsAndSpec.length - 1));
    }

    public <T, S extends Spec<T>> JFactory register(Class<S> specClass) {
        getPropertyAliasesInSpec(specClass).stream().filter(Objects::nonNull).forEach(propertyAliases -> {
            if (propertyAliases.value().length > 0) {
                AliasSetStore.AliasSet aliasSet = aliasOfSpec(specClass);
                for (PropertyAlias propertyAlias : propertyAliases.value())
                    aliasSet.alias(propertyAlias.alias(), propertyAlias.property());
            }
        });
        factorySet.registerSpecClassFactory(specClass);
        return this;
    }

    private List<PropertyAliases> getPropertyAliasesInSpec(Class<?> specClass) {
        return new ArrayList<PropertyAliases>() {{
            Class<?> superclass = specClass.getSuperclass();
            if (!superclass.equals(Object.class))
                addAll(getPropertyAliasesInSpec(superclass));
            add(specClass.getAnnotation(PropertyAliases.class));
        }};
    }

    public <T> Factory<T> specFactory(String specName) {
        return factorySet.querySpecClassFactory(specName);
    }

    public <T, S extends Spec<T>> Factory<T> specFactory(Class<S> specClass) {
        register(specClass);
        return factorySet.querySpecClassFactory(specClass);
    }

    public <T> T create(Class<T> type) {
        return type(type).create();
    }

    public <T, S extends Spec<T>> T createAs(Class<S> spec) {
        return spec(spec).create();
    }

    public <T, S extends Spec<T>> T createAs(Class<S> spec, Consumer<S> trait) {
        return spec(spec, trait).create();
    }

    public <T> T createAs(String... traitsAndSpec) {
        return this.<T>spec(traitsAndSpec).create();
    }

    public <T> JFactory registerDefaultValueFactory(Class<T> type, DefaultValueFactory<T> factory) {
        factorySet.registerDefaultValueFactory(type, factory);
        return this;
    }

    public JFactory ignoreDefaultValue(Predicate<PropertyWriter<?>> ignoreProperty) {
        ignoreDefaultValues.add(ignoreProperty);
        return this;
    }

    <T> boolean shouldCreateDefaultValue(PropertyWriter<T> propertyWriter) {
        return ignoreDefaultValues.stream().noneMatch(p -> p.test(propertyWriter));
    }

    public AliasSetStore.AliasSet aliasOf(Class<?> type) {
        return aliasSetStore.aliasSet(BeanClass.create(type));
    }

    public <T, S extends Spec<T>> AliasSetStore.AliasSet aliasOfSpec(Class<S> specClass) {
        return aliasSetStore.specAliasSet(specClass);
    }

    public JFactory removeGlobalSpec(Class<?> type) {
        factorySet.removeGlobalSpec(BeanClass.create(type));
        return this;
    }

    public Set<String> specNames() {
        return factorySet.specNames();
    }

    public JFactory clear() {
        getDataRepository().clear();
        return this;
    }
}

1	package com.github.leeonky.jfactory;
2
3	import com.github.leeonky.util.BeanClass;
4	import com.github.leeonky.util.GenericBeanClass;
5	import com.github.leeonky.util.PropertyWriter;
6	import com.github.leeonky.util.TypeReference;
7
8	import java.lang.reflect.Array;
9	import java.util.*;
10	import java.util.function.Consumer;
11	import java.util.function.Predicate;
12
13	import static com.github.leeonky.jfactory.DefaultBuilder.BuildFrom.SPEC;
14	import static com.github.leeonky.jfactory.DefaultBuilder.BuildFrom.TYPE;
15
16	public class JFactory {
17	final AliasSetStore aliasSetStore = new AliasSetStore();	1✔
18	private final FactorySet factorySet = new FactorySet();	1✔
19	private final DataRepository dataRepository;
20	private final Set<Predicate<PropertyWriter<?>>> ignoreDefaultValues = new LinkedHashSet<>();	1✔
21
22	public JFactory() {	1✔
23	dataRepository = new MemoryDataRepository();	1✔
24	}	1✔
25
26	public JFactory(DataRepository dataRepository) {	1✔
27	this.dataRepository = dataRepository;	1✔
28	}	1✔
29
30	public DataRepository getDataRepository() {
31	return dataRepository;	1✔
32	}
33
34	public <T> Factory<T> factory(Class<T> type) {
35	return factory(BeanClass.create(type));	1✔
36	}
37
38	public <T> Factory<T> factory(BeanClass<T> type) {
39	return factorySet.queryObjectFactory(type);	1✔
40	}
41
42	public <T> Builder<T> type(Class<T> type) {
43	return type(BeanClass.create(type));	1✔
44	}
45
46	public <T> Builder<T> type(BeanClass<T> type) {
47	return new DefaultBuilder<>(factorySet.queryObjectFactory(type), this, TYPE);	1✔
48	}
49
50	public <T> Builder<T> type(TypeReference<T> type) {
51	return type(type.getType());	1✔
52	}
53
54	public <T, S extends Spec<T>> Builder<T> spec(Class<S> specClass) {
55	return new DefaultBuilder<>((ObjectFactory<T>) specFactory(specClass), this, SPEC);	1✔
56	}
57
58	public <T, S extends Spec<T>> Builder<T> spec(Class<S> specClass, Consumer<S> trait) {
59	return new DefaultBuilder<>(factorySet.createSpecFactory(specClass, trait), this, SPEC);	1✔
60	}
61
62	public <T, S extends Spec<T>> Builder<T[]> specs(Class<S> specClass) {
63	Factory<T> specFactory = specFactory(specClass);	1✔
64	Class<T[]> arrayType = (Class<T[]>) Array.newInstance(specFactory.getType().getType(), 0).getClass();	1✔
65	ObjectFactory<T[]> listFactory = new ObjectFactory<>(BeanClass.create(arrayType), factorySet);	1✔
66	listFactory.spec(ins -> ins.spec().property("[]").is(specClass));	1✔
67	return new DefaultBuilder<>(listFactory, this, TYPE);	1✔
68	}
69
70	public <T, S extends Spec<T>, L extends List<T>> Builder<L> specs(Class<L> collectionType, Class<S> specClass) {
71	Factory<T> specFactory = specFactory(specClass);	1✔
72	ObjectFactory<L> listFactory = new ObjectFactory<>(GenericBeanClass.create(collectionType,	1✔
73	specFactory.getType().getType()), factorySet);	1✔
74	listFactory.spec(ins -> ins.spec().property("[]").is(specClass));	1✔
75	return new DefaultBuilder<>(listFactory, this, TYPE);	1✔
76	}
77
78	public <T> Builder<T> spec(String... traitsAndSpec) {
79	String specName = traitsAndSpec[traitsAndSpec.length - 1];	1✔
80	if (specName.endsWith("[]")) {	1✔
81	specName = specName.replace("[]", "");	1✔
82	Factory<Object> specFactory = specFactory(specName);	1✔
83	ObjectFactory<?> listFactory = new ObjectFactory<>(GenericBeanClass.create(List.class, specFactory.getType().getType()), factorySet);	1✔
84	traitsAndSpec[traitsAndSpec.length - 1] = specName;	1✔
85	listFactory.spec(ins -> ins.spec().property("[]").is(traitsAndSpec));	1✔
86	return new DefaultBuilder(listFactory, this, TYPE);	1✔
87	}
88	return new DefaultBuilder<>((ObjectFactory<T>) specFactory(specName), this, SPEC)	1✔
89	.traits(Arrays.copyOf(traitsAndSpec, traitsAndSpec.length - 1));	1✔
90	}
91
92	public <T, S extends Spec<T>> JFactory register(Class<S> specClass) {
93	getPropertyAliasesInSpec(specClass).stream().filter(Objects::nonNull).forEach(propertyAliases -> {	1✔
94	if (propertyAliases.value().length > 0) {	1✔
95	AliasSetStore.AliasSet aliasSet = aliasOfSpec(specClass);	1✔
96	for (PropertyAlias propertyAlias : propertyAliases.value())	1✔
97	aliasSet.alias(propertyAlias.alias(), propertyAlias.property());	1✔
98	}
99	});	1✔
100	factorySet.registerSpecClassFactory(specClass);	1✔
101	return this;	1✔
102	}
103
104	private List<PropertyAliases> getPropertyAliasesInSpec(Class<?> specClass) {
105	return new ArrayList<PropertyAliases>() {{	1✔
106	Class<?> superclass = specClass.getSuperclass();	1✔
107	if (!superclass.equals(Object.class))	1✔
108	addAll(getPropertyAliasesInSpec(superclass));	1✔
109	add(specClass.getAnnotation(PropertyAliases.class));	1✔
110	}};	1✔
111	}
112
113	public <T> Factory<T> specFactory(String specName) {
114	return factorySet.querySpecClassFactory(specName);	1✔
115	}
116
117	public <T, S extends Spec<T>> Factory<T> specFactory(Class<S> specClass) {
118	register(specClass);	1✔
119	return factorySet.querySpecClassFactory(specClass);	1✔
120	}
121
122	public <T> T create(Class<T> type) {
123	return type(type).create();	1✔
124	}
125
126	public <T, S extends Spec<T>> T createAs(Class<S> spec) {
127	return spec(spec).create();	1✔
128	}
129
130	public <T, S extends Spec<T>> T createAs(Class<S> spec, Consumer<S> trait) {
131	return spec(spec, trait).create();	1✔
132	}
133
134	public <T> T createAs(String... traitsAndSpec) {
135	return this.<T>spec(traitsAndSpec).create();	1✔
136	}
137
138	public <T> JFactory registerDefaultValueFactory(Class<T> type, DefaultValueFactory<T> factory) {
139	factorySet.registerDefaultValueFactory(type, factory);	1✔
140	return this;	1✔
141	}
142
143	public JFactory ignoreDefaultValue(Predicate<PropertyWriter<?>> ignoreProperty) {
144	ignoreDefaultValues.add(ignoreProperty);	1✔
145	return this;	1✔
146	}
147
148	<T> boolean shouldCreateDefaultValue(PropertyWriter<T> propertyWriter) {
149	return ignoreDefaultValues.stream().noneMatch(p -> p.test(propertyWriter));	1✔
150	}
151
152	public AliasSetStore.AliasSet aliasOf(Class<?> type) {
153	return aliasSetStore.aliasSet(BeanClass.create(type));	1✔
154	}
155
156	public <T, S extends Spec<T>> AliasSetStore.AliasSet aliasOfSpec(Class<S> specClass) {
157	return aliasSetStore.specAliasSet(specClass);	1✔
158	}
159
160	public JFactory removeGlobalSpec(Class<?> type) {
161	factorySet.removeGlobalSpec(BeanClass.create(type));	1✔
162	return this;	1✔
163	}
164
165	public Set<String> specNames() {
UNCOV 166	return factorySet.specNames();	×
167	}
168
169	public JFactory clear() {
170	getDataRepository().clear();	1✔
171	return this;	1✔
172	}
173	}

leeonky / test-charm-java / 296

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