leeonky / test-charm-java / 156

Committed 20 Mar 2025 01:53PM UTC coverage: 74.243% (-0.2%) from 74.475%

Build # 156

Build Type

push

circleci

Committed by

leeonky

Commit Message

Refactor

Run Details

14 of 15 new or added lines in 12 files covered. (93.33%)

126 existing lines in 29 files now uncovered.

7947 of 10704 relevant lines covered (74.24%)

0.74 hits per line

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

97.44

/DAL-java/src/main/java/com/github/leeonky/dal/ast/opt/Factory.java

package com.github.leeonky.dal.ast.opt;

import com.github.leeonky.dal.ast.node.DALExpression;
import com.github.leeonky.dal.ast.node.ExecutableNode;
import com.github.leeonky.dal.ast.node.SchemaComposeNode;
import com.github.leeonky.dal.compiler.Notations;
import com.github.leeonky.dal.runtime.Data;
import com.github.leeonky.dal.runtime.ExclamationData;
import com.github.leeonky.dal.runtime.Operators;
import com.github.leeonky.dal.runtime.RemarkData;
import com.github.leeonky.dal.runtime.RuntimeContextBuilder.DALRuntimeContext;
import com.github.leeonky.interpreter.Notation;

import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

public class Factory {
    public static DALOperator logical(Notation<?, ?, ?, ?, ?> notation, ExpressionContextData.SupplierSupplierData logical) {
        return new Operator(Precedence.LOGICAL, notation, ExpressionContextData.adapt(logical), true, Operators.NA);
    }

    public static DALOperator plusSub(Notation<?, ?, ?, ?, ?> notation, ExpressionContextData.DataOptDataContextData plusSub, Operators type) {
        return new Operator(Precedence.PLUS_SUB, notation, ExpressionContextData.adapt(plusSub), false, type);
    }

    public static DALOperator mulDiv(Notation<?, ?, ?, ?, ?> notation, ExpressionContextData.DataOptDataContextData mulDiv, Operators type) {
        return new Operator(Precedence.MUL_DIV, notation, ExpressionContextData.adapt(mulDiv), false, type);
    }

    public static DALOperator comparator(Notation<?, ?, ?, ?, ?> notation, ExpressionContextData operation) {
        return new Operator(Precedence.COMPARISON, notation, operation, true, Operators.NA);
    }

    public static DALOperator unary(Notation<?, ?, ?, ?, ?> notation, ExpressionContextData unary) {
        return new Operator(Precedence.UNARY_OPERATION, notation, unary, true, Operators.NA) {
            @Override
            public String inspect(String node1, String node2) {
                return notation.getLabel() + node2;
            }
        };
    }

    public static DALOperator executable(Notation<?, ?, ?, ?, ?> notation) {
        return new DALOperator(Precedence.PROPERTY, notation.getLabel(), false, Operators.NA) {
            @Override
            public Data calculateData(DALExpression expression, DALRuntimeContext context) {
                return ((ExecutableNode) expression.right()).getValue(expression.left(), context);
            }

            @Override
            public String inspect(String node1, String node2) {
                return String.format("%s%s%s", node1, label, node2);
            }
        };
    }

    public static DALOperator is() {
        return new DALOperator(Precedence.VERIFICATION, Notations.Operators.IS.getLabel(), true, Operators.NA) {
            @Override
            public Data calculateData(DALExpression expression, DALRuntimeContext context) {
                return ((SchemaComposeNode) expression.right()).verify(expression.left(), context);
            }
        };
    }

    public static DALOperator which() {
        return new DALOperator(Precedence.WHICH, Notations.Operators.WHICH.getLabel(), true, Operators.NA) {
            @Override
            public Data calculateData(DALExpression expression, DALRuntimeContext context) {
                return expression.left().evaluateData(context).execute(() -> expression.right().evaluateData(context));
            }
        };
    }

    public static DALOperator dataRemark() {
        return new DALOperator(Precedence.REMARK_EXCLAMATION, "DATA_REMARK", false, Operators.NA) {

            @Override
            public Data calculateData(DALExpression expression, DALRuntimeContext context) {
                return context.invokeDataRemark(new RemarkData(expression.left().evaluateData(context), context,
                        expression.right().inspect()));
            }

            @Override
            public String inspect(String node1, String node2) {
                return node1 + "(" + node2 + ")";
            }
        };
    }

    public static DALOperator exclamation() {
        return new DALOperator(Precedence.REMARK_EXCLAMATION, "EXCLAMATION", false, Operators.NA) {

            @Override
            public Data calculateData(DALExpression expression, DALRuntimeContext context) {
                return context.invokeExclamations(new ExclamationData(expression.left().evaluateData(context),
                        expression.left(), expression.right(), context));
            }

            @Override
            public String inspect(String node1, String node2) {
                return node1 + node2;
            }
        };
    }

    public static DALOperator equal() {
        return new VerificationOperator(Notations.Operators.EQUAL.getLabel(), Operators.EQUAL);
    }

    public static DALOperator match() {
        return new VerificationOperator(Notations.Operators.MATCHER.getLabel(), Operators.MATCH);
    }

    public interface ExpressionContextData extends BiFunction<DALExpression, DALRuntimeContext, Data> {
        static ExpressionContextData adapt(SupplierSupplierData operation) {
            return (expression, context) -> operation.apply(() -> expression.left().evaluateData(context),
                    () -> expression.right().evaluateData(context));
        }

        static ExpressionContextData adapt(DataDataObject operation) {
            return (expression, context) -> context.wrap(() -> operation.apply(expression.left().evaluateData(context), expression.right().evaluateData(context)));
        }

        static ExpressionContextData adapt(DataOptDataContextData operation) {
            return (expression, context) -> operation.apply(expression.left().evaluateData(context),
                    expression.operator(), expression.right().evaluateData(context), context);
        }

        static ExpressionContextData adapt(DataContextData operation) {
            return (expression, context) -> operation.apply(expression.right().evaluateData(context), context);
        }

        static ExpressionContextData adapt(DataObject operation) {
            return (expression, context) -> context.wrap(() -> operation.apply(expression.right().evaluate(context)));
        }

        interface SupplierSupplierData extends BiFunction<Supplier<Data>, Supplier<Data>, Data> {
        }

        interface DataOptDataContextData extends QuadFunction<Data, DALOperator, Data, DALRuntimeContext, Data> {
        }

        interface DataContextData extends BiFunction<Data, DALRuntimeContext, Data> {
        }

        interface DataObject extends Function<Object, Object> {
        }

        interface DataDataObject extends BiFunction<Data, Data, Object> {
        }
    }

    static class Operator extends DALOperator {
        private final ExpressionContextData operation;

        public Operator(int precedence, Notation<?, ?, ?, ?, ?> notation,
                        ExpressionContextData operation, boolean needInspect, Operators type) {
            super(precedence, notation.getLabel(), needInspect, type);
            this.operation = operation;
        }

        @Override
        public Data calculateData(DALExpression expression, DALRuntimeContext context) {
            return operation.apply(expression, context);
        }
    }

    public interface QuadFunction<T1, T2, T3, T4, R> {
        R apply(T1 obj1, T2 obj2, T3 obj3, T4 obj4);
    }

    public static class VerificationOperator extends DALOperator {
        public VerificationOperator(String label, Operators type) {
            super(Precedence.VERIFICATION, label, true, type);
        }

        @Override
        public Data calculateData(DALExpression expression, DALRuntimeContext context) {
            return expression.right().verify(expression.operator(), expression.left(), context);
        }

        @Override
        public String inspect(String node1, String node2) {
            return String.format("%s%s %s", node1, label, node2);
        }
    }
}

1	package com.github.leeonky.dal.ast.opt;
2
3	import com.github.leeonky.dal.ast.node.DALExpression;
4	import com.github.leeonky.dal.ast.node.ExecutableNode;
5	import com.github.leeonky.dal.ast.node.SchemaComposeNode;
6	import com.github.leeonky.dal.compiler.Notations;
7	import com.github.leeonky.dal.runtime.Data;
8	import com.github.leeonky.dal.runtime.ExclamationData;
9	import com.github.leeonky.dal.runtime.Operators;
10	import com.github.leeonky.dal.runtime.RemarkData;
11	import com.github.leeonky.dal.runtime.RuntimeContextBuilder.DALRuntimeContext;
12	import com.github.leeonky.interpreter.Notation;
13
14	import java.util.function.BiFunction;
15	import java.util.function.Function;
16	import java.util.function.Supplier;
17
UNCOV 18	public class Factory {	×
19	public static DALOperator logical(Notation<?, ?, ?, ?, ?> notation, ExpressionContextData.SupplierSupplierData logical) {
20	return new Operator(Precedence.LOGICAL, notation, ExpressionContextData.adapt(logical), true, Operators.NA);	1✔
21	}
22
23	public static DALOperator plusSub(Notation<?, ?, ?, ?, ?> notation, ExpressionContextData.DataOptDataContextData plusSub, Operators type) {
24	return new Operator(Precedence.PLUS_SUB, notation, ExpressionContextData.adapt(plusSub), false, type);	1✔
25	}
26
27	public static DALOperator mulDiv(Notation<?, ?, ?, ?, ?> notation, ExpressionContextData.DataOptDataContextData mulDiv, Operators type) {
28	return new Operator(Precedence.MUL_DIV, notation, ExpressionContextData.adapt(mulDiv), false, type);	1✔
29	}
30
31	public static DALOperator comparator(Notation<?, ?, ?, ?, ?> notation, ExpressionContextData operation) {
32	return new Operator(Precedence.COMPARISON, notation, operation, true, Operators.NA);	1✔
33	}
34
35	public static DALOperator unary(Notation<?, ?, ?, ?, ?> notation, ExpressionContextData unary) {
36	return new Operator(Precedence.UNARY_OPERATION, notation, unary, true, Operators.NA) {	1✔
37	@Override
38	public String inspect(String node1, String node2) {
39	return notation.getLabel() + node2;	1✔
40	}
41	};
42	}
43
44	public static DALOperator executable(Notation<?, ?, ?, ?, ?> notation) {
45	return new DALOperator(Precedence.PROPERTY, notation.getLabel(), false, Operators.NA) {	1✔
46	@Override
47	public Data calculateData(DALExpression expression, DALRuntimeContext context) {
48	return ((ExecutableNode) expression.right()).getValue(expression.left(), context);	1✔
49	}
50
51	@Override
52	public String inspect(String node1, String node2) {
53	return String.format("%s%s%s", node1, label, node2);	1✔
54	}
55	};
56	}
57
58	public static DALOperator is() {
59	return new DALOperator(Precedence.VERIFICATION, Notations.Operators.IS.getLabel(), true, Operators.NA) {	1✔
60	@Override
61	public Data calculateData(DALExpression expression, DALRuntimeContext context) {
62	return ((SchemaComposeNode) expression.right()).verify(expression.left(), context);	1✔
63	}
64	};
65	}
66
67	public static DALOperator which() {
68	return new DALOperator(Precedence.WHICH, Notations.Operators.WHICH.getLabel(), true, Operators.NA) {	1✔
69	@Override
70	public Data calculateData(DALExpression expression, DALRuntimeContext context) {
71	return expression.left().evaluateData(context).execute(() -> expression.right().evaluateData(context));	1✔
72	}
73	};
74	}
75
76	public static DALOperator dataRemark() {
77	return new DALOperator(Precedence.REMARK_EXCLAMATION, "DATA_REMARK", false, Operators.NA) {	1✔
78
79	@Override
80	public Data calculateData(DALExpression expression, DALRuntimeContext context) {
81	return context.invokeDataRemark(new RemarkData(expression.left().evaluateData(context), context,	1✔
82	expression.right().inspect()));	1✔
83	}
84
85	@Override
86	public String inspect(String node1, String node2) {
87	return node1 + "(" + node2 + ")";	1✔
88	}
89	};
90	}
91
92	public static DALOperator exclamation() {
93	return new DALOperator(Precedence.REMARK_EXCLAMATION, "EXCLAMATION", false, Operators.NA) {	1✔
94
95	@Override
96	public Data calculateData(DALExpression expression, DALRuntimeContext context) {
97	return context.invokeExclamations(new ExclamationData(expression.left().evaluateData(context),	1✔
98	expression.left(), expression.right(), context));	1✔
99	}
100
101	@Override
102	public String inspect(String node1, String node2) {
103	return node1 + node2;	1✔
104	}
105	};
106	}
107
108	public static DALOperator equal() {
109	return new VerificationOperator(Notations.Operators.EQUAL.getLabel(), Operators.EQUAL);	1✔
110	}
111
112	public static DALOperator match() {
113	return new VerificationOperator(Notations.Operators.MATCHER.getLabel(), Operators.MATCH);	1✔
114	}
115
116	public interface ExpressionContextData extends BiFunction<DALExpression, DALRuntimeContext, Data> {
117	static ExpressionContextData adapt(SupplierSupplierData operation) {
118	return (expression, context) -> operation.apply(() -> expression.left().evaluateData(context),	1✔
119	() -> expression.right().evaluateData(context));	1✔
120	}
121
122	static ExpressionContextData adapt(DataDataObject operation) {
123	return (expression, context) -> context.wrap(() -> operation.apply(expression.left().evaluateData(context), expression.right().evaluateData(context)));	1✔
124	}
125
126	static ExpressionContextData adapt(DataOptDataContextData operation) {
127	return (expression, context) -> operation.apply(expression.left().evaluateData(context),	1✔
128	expression.operator(), expression.right().evaluateData(context), context);	1✔
129	}
130
131	static ExpressionContextData adapt(DataContextData operation) {
132	return (expression, context) -> operation.apply(expression.right().evaluateData(context), context);	1✔
133	}
134
135	static ExpressionContextData adapt(DataObject operation) {
136	return (expression, context) -> context.wrap(() -> operation.apply(expression.right().evaluate(context)));	1✔
137	}
138
139	interface SupplierSupplierData extends BiFunction<Supplier<Data>, Supplier<Data>, Data> {
140	}
141
142	interface DataOptDataContextData extends QuadFunction<Data, DALOperator, Data, DALRuntimeContext, Data> {
143	}
144
145	interface DataContextData extends BiFunction<Data, DALRuntimeContext, Data> {
146	}
147
148	interface DataObject extends Function<Object, Object> {
149	}
150
151	interface DataDataObject extends BiFunction<Data, Data, Object> {
152	}
153	}
154
155	static class Operator extends DALOperator {
156	private final ExpressionContextData operation;
157
158	public Operator(int precedence, Notation<?, ?, ?, ?, ?> notation,
159	ExpressionContextData operation, boolean needInspect, Operators type) {
160	super(precedence, notation.getLabel(), needInspect, type);	1✔
161	this.operation = operation;	1✔
162	}	1✔
163
164	@Override
165	public Data calculateData(DALExpression expression, DALRuntimeContext context) {
166	return operation.apply(expression, context);	1✔
167	}
168	}
169
170	public interface QuadFunction<T1, T2, T3, T4, R> {
171	R apply(T1 obj1, T2 obj2, T3 obj3, T4 obj4);
172	}
173
174	public static class VerificationOperator extends DALOperator {
175	public VerificationOperator(String label, Operators type) {
176	super(Precedence.VERIFICATION, label, true, type);	1✔
177	}	1✔
178
179	@Override
180	public Data calculateData(DALExpression expression, DALRuntimeContext context) {
181	return expression.right().verify(expression.operator(), expression.left(), context);	1✔
182	}
183
184	@Override
185	public String inspect(String node1, String node2) {
186	return String.format("%s%s %s", node1, label, node2);	1✔
187	}
188	}
189	}

leeonky / test-charm-java / 156

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