leeonky / test-charm-java / 378

Committed 13 Oct 2025 03:47PM UTC coverage: 75.288% (-0.02%) from 75.309%

Build # 378

Build Type

push

circleci

Committed by

leeonky

Commit Message

throw error when sub query result size > 1

Run Details

4 of 4 new or added lines in 2 files covered. (100.0%)

2 existing lines in 2 files now uncovered.

8893 of 11812 relevant lines covered (75.29%)

0.75 hits per line

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

98.61

/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<>();
    }

    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<>();	1✔
38	}
39
40	final public Spec<T> createSpecWithContext(Optional<Association> association, Optional<ReverseAssociation> reverseAssociation, ObjectProducer<?> objectProducer) {
41	Spec<T> spec = createSpec();	1✔
42	spec.association = association;	1✔
43	spec.reverseAssociation = reverseAssociation;	1✔
44	spec.objectProducer = objectProducer;	1✔
45	return spec;	1✔
46	}
47
48	@Override
49	public final Factory<T> constructor(Function<Instance<T>, T> constructor) {
50	this.constructor = Objects.requireNonNull(constructor);	1✔
51	return this;	1✔
52	}
53
54	@Override
55	public Factory<T> spec(Consumer<Instance<T>> spec) {
56	this.spec = Objects.requireNonNull(spec);	1✔
57	return this;	1✔
58	}
59
60	@Override
61	public Factory<T> spec(String name, Consumer<Instance<T>> trait) {
62	traits.put(name, Objects.requireNonNull(trait));	1✔
63	traitPatterns.put(name, Pattern.compile(name));	1✔
64	return this;	1✔
65	}
66
67	public final T create(Instance<T> instance) {
68	instance.getSequence();	1✔
69	return constructor.apply(instance);	1✔
70	}
71
72	@Override
73	public BeanClass<T> getType() {
74	return type;	1✔
75	}
76
77	@Override
78	public Factory<T> transformer(String property, Transformer transformer) {
79	transformers.put(property, transformer);	1✔
80	return this;	1✔
81	}
82
83	private static class TraitExecutor<T> {
84	private final Consumer<Instance<T>> action;
85	private final List<Object> args = new ArrayList<>();	1✔
86
87	public TraitExecutor(Matcher matcher, Consumer<Instance<T>> action) {	1✔
88	for (int i = 0; i < matcher.groupCount(); i++)	1✔
89	args.add(matcher.group(i + 1));	1✔
90	this.action = action;	1✔
91	}	1✔
92
93	public TraitExecutor(Consumer<Instance<T>> action) {	1✔
94	this.action = action;	1✔
95	}	1✔
96
97	public void execute(Instance<T> instance) {
98	((ObjectInstance<T>) instance).runTraitWithParams(args.toArray(), action);	1✔
99	}	1✔
100	}
101
102	public void collectSpec(Collection<String> traits, ObjectInstance<T> instance) {
103	spec.accept(instance);	1✔
104	collectSubSpec(instance);	1✔
105	for (String name : traits)	1✔
106	queryTrait(name).execute(instance);	1✔
107	}	1✔
108
109	private TraitExecutor<T> queryTrait(String name) {
110	Consumer<Instance<T>> action = traits.get(name);	1✔
111	if (action != null)	1✔
112	return new TraitExecutor<>(action);	1✔
113	List<Matcher> matchers = traitPatterns.values().stream().map(p -> p.matcher(name)).filter(Matcher::matches)	1✔
114	.collect(Collectors.toList());	1✔
115	if (matchers.size() == 1)	1✔
116	return new TraitExecutor<>(matchers.get(0), traits.get(matchers.get(0).pattern().pattern()));	1✔
117	if (matchers.size() > 1)	1✔
118	throw new IllegalArgumentException(String.format("Ambiguous trait pattern: %s, candidates are:\n%s", name,	1✔
119	matchers.stream().map(p -> " " + p.pattern().pattern()).collect(Collectors.joining("\n"))));	1✔
120	throw new IllegalArgumentException("Trait `" + name + "` not exist");	1✔
121	}
122
123	protected void collectSubSpec(ObjectInstance<T> instance) {
124	}	1✔
125
126	public ObjectInstance<T> createInstance(Arguments argument, Optional<Association> association,
127	Optional<ReverseAssociation> reverseAssociation,
128	ObjectProducer<?> objectProducer) {
129	Spec<T> spec = createSpecWithContext(association, reverseAssociation, objectProducer);	1✔
130	ObjectInstance<T> objectInstance = new ObjectInstance<>(spec, argument,	1✔
131	factorySet.sequence(getType().getType()));	1✔
132	spec.setInstance(objectInstance);	1✔
133	return objectInstance;	1✔
134	}
135
136	public FactorySet getFactorySet() {
137	return factorySet;	1✔
138	}
139
140	public ObjectFactory<T> getBase() {
UNCOV 141	return this;	×
142	}
143
144	public Object transform(String name, Object value) {
145	return queryTransformer(name, () -> passThrough).checkAndTransform(value);	1✔
146	}
147
148	protected Transformer queryTransformer(String name, Supplier<Transformer> fallback) {
149	return transformers.getOrDefault(name, fallback(name, fallback).get());	1✔
150	}
151
152	protected Supplier<Transformer> fallback(String name, Supplier<Transformer> fallback) {
153	return () -> getType().getType().getSuperclass() == null ? fallback.get()	1✔
154	: factorySet.queryObjectFactory(BeanClass.create(getType().getType().getSuperclass()))	1✔
155	.queryTransformer(name, fallback);	1✔
156	}
157	}

leeonky / test-charm-java / 378

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