leeonky / test-charm-java / 114

Committed 09 Feb 2025 05:45PM UTC coverage: 73.251% (-0.1%) from 73.358%

Build # 114

Build Type

push

circleci

Committed by

leeonky

Commit Message

Refactor

Run Details

0 of 70 new or added lines in 3 files covered. (0.0%)

15 existing lines in 7 files now uncovered.

7665 of 10464 relevant lines covered (73.25%)

0.73 hits per line

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

90.48

/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.*;
import com.github.leeonky.dal.runtime.RuntimeException;
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 Object calculate(DALExpression expression, DALRuntimeContext context) {
                try {
                    return expression.left().evaluateData(context).execute(() -> expression.right().evaluate(context));
                } catch (IllegalStateException e) {
                    throw new RuntimeException(e.getMessage(), getPosition());
                }
            }
        };
    }

    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) -> context.wrap(operation.apply(() -> expression.left().evaluateData(context),
                    () -> expression.right().evaluateData(context)).instance());
        }

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

        @Override
        public boolean isVerification() {
            return true;
        }
    }
}

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

leeonky / test-charm-java / 114

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