leeonky / test-charm-java / 390

Committed 18 Oct 2025 04:40PM UTC coverage: 75.298% (+0.01%) from 75.288%

Build # 390

Build Type

push

circleci

Committed by

leeonky

Commit Message

refactor

Run Details

8 of 8 new or added lines in 5 files covered. (100.0%)

19 existing lines in 8 files now uncovered.

8895 of 11813 relevant lines covered (75.3%)

0.75 hits per line

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

98.63

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

package com.github.leeonky.jfactory;

import com.github.leeonky.util.BeanClass;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

class ObjectFactory<T> implements Factory<T> {
    protected final FactorySet factorySet;
    private final BeanClass<T> type;
    private final Map<String, Consumer<Instance<T>>> traits = new LinkedHashMap<>();
    private final Map<String, Pattern> traitPatterns = new LinkedHashMap<>();
    private final Map<String, Transformer> transformers = new LinkedHashMap<>();
    private final Transformer passThrough = input -> input;
    private Function<Instance<T>, T> constructor = this::defaultConstruct;
    private Consumer<Instance<T>> spec = (instance) -> {
    };

    public ObjectFactory(BeanClass<T> type, FactorySet factorySet) {
        this.type = type;
        this.factorySet = factorySet;
    }

    @SuppressWarnings("unchecked")
    private T defaultConstruct(Instance<T> instance) {
        return getType().isCollection()
                ? (T) getType().createCollection(Collections.nCopies(instance.collectionSize(), getType().getElementType().createDefault()))
                : getType().newInstance();
    }

    protected Spec<T> createSpec() {
        return new Spec<T>() {
            @Override
            public BeanClass<T> getType() {
                return type;
            }
        };
    }

    final public Spec<T> createSpecWithContext(Optional<Association> association, Optional<ReverseAssociation> reverseAssociation, ObjectProducer<?> objectProducer) {
        Spec<T> spec = createSpec();
        spec.association = association;
        spec.reverseAssociation = reverseAssociation;
        spec.objectProducer = objectProducer;
        return spec;
    }

    @Override
    public final Factory<T> constructor(Function<Instance<T>, T> constructor) {
        this.constructor = Objects.requireNonNull(constructor);
        return this;
    }

    @Override
    public Factory<T> spec(Consumer<Instance<T>> spec) {
        this.spec = Objects.requireNonNull(spec);
        return this;
    }

    @Override
    public Factory<T> spec(String name, Consumer<Instance<T>> trait) {
        traits.put(name, Objects.requireNonNull(trait));
        traitPatterns.put(name, Pattern.compile(name));
        return this;
    }

    public final T create(Instance<T> instance) {
        instance.getSequence();
        return constructor.apply(instance);
    }

    @Override
    public BeanClass<T> getType() {
        return type;
    }

    @Override
    public Factory<T> transformer(String property, Transformer transformer) {
        transformers.put(property, transformer);
        return this;
    }

    private static class TraitExecutor<T> {
        private final Consumer<Instance<T>> action;
        private final List<Object> args = new ArrayList<>();

        public TraitExecutor(Matcher matcher, Consumer<Instance<T>> action) {
            for (int i = 0; i < matcher.groupCount(); i++)
                args.add(matcher.group(i + 1));
            this.action = action;
        }

        public TraitExecutor(Consumer<Instance<T>> action) {
            this.action = action;
        }

        public void execute(Instance<T> instance) {
            ((ObjectInstance<T>) instance).runTraitWithParams(args.toArray(), action);
        }
    }

    public void collectSpec(Collection<String> traits, ObjectInstance<T> instance) {
        spec.accept(instance);
        collectSubSpec(instance);
        for (String name : traits)
            queryTrait(name).execute(instance);
    }

    private TraitExecutor<T> queryTrait(String name) {
        Consumer<Instance<T>> action = traits.get(name);
        if (action != null)
            return new TraitExecutor<>(action);
        List<Matcher> matchers = traitPatterns.values().stream().map(p -> p.matcher(name)).filter(Matcher::matches)
                .collect(Collectors.toList());
        if (matchers.size() == 1)
            return new TraitExecutor<>(matchers.get(0), traits.get(matchers.get(0).pattern().pattern()));
        if (matchers.size() > 1)
            throw new IllegalArgumentException(String.format("Ambiguous trait pattern: %s, candidates are:\n%s", name,
                    matchers.stream().map(p -> "  " + p.pattern().pattern()).collect(Collectors.joining("\n"))));
        throw new IllegalArgumentException("Trait `" + name + "` not exist");
    }

    protected void collectSubSpec(ObjectInstance<T> instance) {
    }

    public ObjectInstance<T> createInstance(Arguments argument, Optional<Association> association,
                                            Optional<ReverseAssociation> reverseAssociation,
                                            ObjectProducer<?> objectProducer) {
        Spec<T> spec = createSpecWithContext(association, reverseAssociation, objectProducer);
        ObjectInstance<T> objectInstance = new ObjectInstance<>(spec, argument,
                factorySet.sequence(getType().getType()));
        spec.setInstance(objectInstance);
        return objectInstance;
    }

    public FactorySet getFactorySet() {
        return factorySet;
    }

    public ObjectFactory<T> getBase() {
        return this;
    }

    public Object transform(String name, Object value) {
        return queryTransformer(name, () -> passThrough).checkAndTransform(value);
    }

    protected Transformer queryTransformer(String name, Supplier<Transformer> fallback) {
        return transformers.getOrDefault(name, fallback(name, fallback).get());
    }

    protected Supplier<Transformer> fallback(String name, Supplier<Transformer> fallback) {
        return () -> getType().getType().getSuperclass() == null ? fallback.get()
                : factorySet.queryObjectFactory(BeanClass.create(getType().getType().getSuperclass()))
                .queryTransformer(name, fallback);
    }
}

1	package com.github.leeonky.jfactory;
2
3	import com.github.leeonky.util.BeanClass;
4
5	import java.util.*;
6	import java.util.function.Consumer;
7	import java.util.function.Function;
8	import java.util.function.Supplier;
9	import java.util.regex.Matcher;
10	import java.util.regex.Pattern;
11	import java.util.stream.Collectors;
12
13	class ObjectFactory<T> implements Factory<T> {
14	protected final FactorySet factorySet;
15	private final BeanClass<T> type;
16	private final Map<String, Consumer<Instance<T>>> traits = new LinkedHashMap<>();	1✔
17	private final Map<String, Pattern> traitPatterns = new LinkedHashMap<>();	1✔
18	private final Map<String, Transformer> transformers = new LinkedHashMap<>();	1✔
19	private final Transformer passThrough = input -> input;	1✔
20	private Function<Instance<T>, T> constructor = this::defaultConstruct;	1✔
21	private Consumer<Instance<T>> spec = (instance) -> {	1✔
22	};	1✔
23
24	public ObjectFactory(BeanClass<T> type, FactorySet factorySet) {	1✔
25	this.type = type;	1✔
26	this.factorySet = factorySet;	1✔
27	}	1✔
28
29	@SuppressWarnings("unchecked")
30	private T defaultConstruct(Instance<T> instance) {
31	return getType().isCollection()	1✔
32	? (T) getType().createCollection(Collections.nCopies(instance.collectionSize(), getType().getElementType().createDefault()))	1✔
33	: getType().newInstance();	1✔
34	}
35
36	protected Spec<T> createSpec() {
37	return new Spec<T>() {	1✔
38	@Override
39	public BeanClass<T> getType() {
40	return type;	1✔
41	}
42	};
43	}
44
45	final public Spec<T> createSpecWithContext(Optional<Association> association, Optional<ReverseAssociation> reverseAssociation, ObjectProducer<?> objectProducer) {
46	Spec<T> spec = createSpec();	1✔
47	spec.association = association;	1✔
48	spec.reverseAssociation = reverseAssociation;	1✔
49	spec.objectProducer = objectProducer;	1✔
50	return spec;	1✔
51	}
52
53	@Override
54	public final Factory<T> constructor(Function<Instance<T>, T> constructor) {
55	this.constructor = Objects.requireNonNull(constructor);	1✔
56	return this;	1✔
57	}
58
59	@Override
60	public Factory<T> spec(Consumer<Instance<T>> spec) {
61	this.spec = Objects.requireNonNull(spec);	1✔
62	return this;	1✔
63	}
64
65	@Override
66	public Factory<T> spec(String name, Consumer<Instance<T>> trait) {
67	traits.put(name, Objects.requireNonNull(trait));	1✔
68	traitPatterns.put(name, Pattern.compile(name));	1✔
69	return this;	1✔
70	}
71
72	public final T create(Instance<T> instance) {
73	instance.getSequence();	1✔
74	return constructor.apply(instance);	1✔
75	}
76
77	@Override
78	public BeanClass<T> getType() {
79	return type;	1✔
80	}
81
82	@Override
83	public Factory<T> transformer(String property, Transformer transformer) {
84	transformers.put(property, transformer);	1✔
85	return this;	1✔
86	}
87
88	private static class TraitExecutor<T> {
89	private final Consumer<Instance<T>> action;
90	private final List<Object> args = new ArrayList<>();	1✔
91
92	public TraitExecutor(Matcher matcher, Consumer<Instance<T>> action) {	1✔
93	for (int i = 0; i < matcher.groupCount(); i++)	1✔
94	args.add(matcher.group(i + 1));	1✔
95	this.action = action;	1✔
96	}	1✔
97
98	public TraitExecutor(Consumer<Instance<T>> action) {	1✔
99	this.action = action;	1✔
100	}	1✔
101
102	public void execute(Instance<T> instance) {
103	((ObjectInstance<T>) instance).runTraitWithParams(args.toArray(), action);	1✔
104	}	1✔
105	}
106
107	public void collectSpec(Collection<String> traits, ObjectInstance<T> instance) {
108	spec.accept(instance);	1✔
109	collectSubSpec(instance);	1✔
110	for (String name : traits)	1✔
111	queryTrait(name).execute(instance);	1✔
112	}	1✔
113
114	private TraitExecutor<T> queryTrait(String name) {
115	Consumer<Instance<T>> action = traits.get(name);	1✔
116	if (action != null)	1✔
117	return new TraitExecutor<>(action);	1✔
118	List<Matcher> matchers = traitPatterns.values().stream().map(p -> p.matcher(name)).filter(Matcher::matches)	1✔
119	.collect(Collectors.toList());	1✔
120	if (matchers.size() == 1)	1✔
121	return new TraitExecutor<>(matchers.get(0), traits.get(matchers.get(0).pattern().pattern()));	1✔
122	if (matchers.size() > 1)	1✔
123	throw new IllegalArgumentException(String.format("Ambiguous trait pattern: %s, candidates are:\n%s", name,	1✔
124	matchers.stream().map(p -> " " + p.pattern().pattern()).collect(Collectors.joining("\n"))));	1✔
125	throw new IllegalArgumentException("Trait `" + name + "` not exist");	1✔
126	}
127
128	protected void collectSubSpec(ObjectInstance<T> instance) {
129	}	1✔
130
131	public ObjectInstance<T> createInstance(Arguments argument, Optional<Association> association,
132	Optional<ReverseAssociation> reverseAssociation,
133	ObjectProducer<?> objectProducer) {
134	Spec<T> spec = createSpecWithContext(association, reverseAssociation, objectProducer);	1✔
135	ObjectInstance<T> objectInstance = new ObjectInstance<>(spec, argument,	1✔
136	factorySet.sequence(getType().getType()));	1✔
137	spec.setInstance(objectInstance);	1✔
138	return objectInstance;	1✔
139	}
140
141	public FactorySet getFactorySet() {
142	return factorySet;	1✔
143	}
144
145	public ObjectFactory<T> getBase() {
UNCOV 146	return this;	×
147	}
148
149	public Object transform(String name, Object value) {
150	return queryTransformer(name, () -> passThrough).checkAndTransform(value);	1✔
151	}
152
153	protected Transformer queryTransformer(String name, Supplier<Transformer> fallback) {
154	return transformers.getOrDefault(name, fallback(name, fallback).get());	1✔
155	}
156
157	protected Supplier<Transformer> fallback(String name, Supplier<Transformer> fallback) {
158	return () -> getType().getType().getSuperclass() == null ? fallback.get()	1✔
159	: factorySet.queryObjectFactory(BeanClass.create(getType().getType().getSuperclass()))	1✔
160	.queryTransformer(name, fallback);	1✔
161	}
162	}

leeonky / test-charm-java / 390

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