#405

Committed 16 Apr 2024 05:58AM UTC coverage: 0.0% (-88.9%) from 88.866%

Build # #405

Build Type

push

Committed by

Commit Message

add encoding to fix coverage report

Run Details

0 of 5353 relevant lines covered (0.0%)

0.0 hits per line

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

0.0

/jetcache-anno/src/main/java/com/alicp/jetcache/anno/method/ExpressionEvaluator.java

/**
 * Created on 2018/1/19.
 */
package com.alicp.jetcache.anno.method;

import com.alicp.jetcache.CacheConfigException;
import org.mvel2.MVEL;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

import java.lang.reflect.Method;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author huangli
 */
public class ExpressionEvaluator implements Function<Object, Object> {
    private static final Pattern pattern = Pattern.compile("\\s*(\\w+)\\s*\\{(.+)\\}\\s*");
    private Function<Object, Object> target;

    public ExpressionEvaluator(String script, Method defineMethod) {
        Object rt[] = parseEL(script);
        EL el = (EL) rt[0];
        String realScript = (String) rt[1];
        if (el == EL.MVEL) {
            target = new MvelEvaluator(realScript);
        } else if (el == EL.SPRING_EL) {
            target = new SpelEvaluator(realScript, defineMethod);
        }
    }

    private Object[] parseEL(String script) {
        if (script == null || script.trim().equals("")) {
            return null;
        }
        Object[] rt = new Object[2];
        Matcher matcher = pattern.matcher(script);
        if (!matcher.matches()) {
            rt[0] = EL.SPRING_EL; // default spel since 2.4
            rt[1] = script;
            return rt;
        } else {
            String s = matcher.group(1);
            if ("spel".equals(s)) {
                rt[0] = EL.SPRING_EL;
            } else if ("mvel".equals(s)) {
                rt[0] = EL.MVEL;
            }/* else if ("buildin".equals(s)) {
                rt[0] = EL.BUILD_IN;
            } */ else {
                throw new CacheConfigException("Can't parse \"" + script + "\"");
            }
            rt[1] = matcher.group(2);
            return rt;
        }
    }

    @Override
    public Object apply(Object o) {
        return target.apply(o);
    }

    Function<Object, Object> getTarget() {
        return target;
    }
}

class MvelEvaluator implements Function<Object, Object> {
    private String script;

    public MvelEvaluator(String script) {
        this.script = script;
    }

    @Override
    public Object apply(Object context) {
        return MVEL.eval(script, context);
    }
}

class SpelEvaluator implements Function<Object, Object> {

    private static ExpressionParser parser;
    private static ParameterNameDiscoverer parameterNameDiscoverer;

    static {
        parser = new SpelExpressionParser();
        parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
    }

    private final Expression expression;
    private String[] parameterNames;

    public SpelEvaluator(String script, Method defineMethod) {
        expression = parser.parseExpression(script);
        if (defineMethod.getParameterCount() > 0) {
            parameterNames = parameterNameDiscoverer.getParameterNames(defineMethod);
        }
    }

    @Override
    public Object apply(Object rootObject) {
        EvaluationContext context = new StandardEvaluationContext(rootObject);
        CacheInvokeContext cic = (CacheInvokeContext) rootObject;
        if (parameterNames != null) {
            for (int i = 0; i < parameterNames.length; i++) {
                context.setVariable(parameterNames[i], cic.getArgs()[i]);
            }
        }
        context.setVariable("result", cic.getResult());
        return expression.getValue(context);
    }
}

1	/**
2	* Created on 2018/1/19.
3	*/
4	package com.alicp.jetcache.anno.method;
5
6	import com.alicp.jetcache.CacheConfigException;
7	import org.mvel2.MVEL;
8	import org.springframework.core.DefaultParameterNameDiscoverer;
9	import org.springframework.core.ParameterNameDiscoverer;
10	import org.springframework.expression.EvaluationContext;
11	import org.springframework.expression.Expression;
12	import org.springframework.expression.ExpressionParser;
13	import org.springframework.expression.spel.standard.SpelExpressionParser;
14	import org.springframework.expression.spel.support.StandardEvaluationContext;
15
16	import java.lang.reflect.Method;
17	import java.util.function.Function;
18	import java.util.regex.Matcher;
19	import java.util.regex.Pattern;
20
21	/**
22	* @author huangli
23	*/
24	public class ExpressionEvaluator implements Function<Object, Object> {
25	private static final Pattern pattern = Pattern.compile("\\s(\\w+)\\s\\{(.+)\\}\\s*");	×
26	private Function<Object, Object> target;
27
28	public ExpressionEvaluator(String script, Method defineMethod) {	×
29	Object rt[] = parseEL(script);	×
30	EL el = (EL) rt[0];	×
31	String realScript = (String) rt[1];	×
32	if (el == EL.MVEL) {	×
33	target = new MvelEvaluator(realScript);	×
34	} else if (el == EL.SPRING_EL) {	×
35	target = new SpelEvaluator(realScript, defineMethod);	×
36	}
37	}	×
38
39	private Object[] parseEL(String script) {
40	if (script == null \|\| script.trim().equals("")) {	×
41	return null;	×
42	}
43	Object[] rt = new Object[2];	×
44	Matcher matcher = pattern.matcher(script);	×
45	if (!matcher.matches()) {	×
46	rt[0] = EL.SPRING_EL; // default spel since 2.4	×
47	rt[1] = script;	×
48	return rt;	×
49	} else {
50	String s = matcher.group(1);	×
51	if ("spel".equals(s)) {	×
52	rt[0] = EL.SPRING_EL;	×
53	} else if ("mvel".equals(s)) {	×
54	rt[0] = EL.MVEL;	×
55	}/* else if ("buildin".equals(s)) {
56	rt[0] = EL.BUILD_IN;
57	} */ else {
58	throw new CacheConfigException("Can't parse \"" + script + "\"");	×
59	}
60	rt[1] = matcher.group(2);	×
61	return rt;	×
62	}
63	}
64
65	@Override
66	public Object apply(Object o) {
67	return target.apply(o);	×
68	}
69
70	Function<Object, Object> getTarget() {
71	return target;	×
72	}
73	}
74
75	class MvelEvaluator implements Function<Object, Object> {
76	private String script;
77
78	public MvelEvaluator(String script) {	×
79	this.script = script;	×
80	}	×
81
82	@Override
83	public Object apply(Object context) {
84	return MVEL.eval(script, context);	×
85	}
86	}
87
88	class SpelEvaluator implements Function<Object, Object> {
89
90	private static ExpressionParser parser;
91	private static ParameterNameDiscoverer parameterNameDiscoverer;
92
93	static {
94	parser = new SpelExpressionParser();	×
95	parameterNameDiscoverer = new DefaultParameterNameDiscoverer();	×
96	}	×
97
98	private final Expression expression;
99	private String[] parameterNames;
100
101	public SpelEvaluator(String script, Method defineMethod) {	×
102	expression = parser.parseExpression(script);	×
103	if (defineMethod.getParameterCount() > 0) {	×
104	parameterNames = parameterNameDiscoverer.getParameterNames(defineMethod);	×
105	}
106	}	×
107
108	@Override
109	public Object apply(Object rootObject) {
110	EvaluationContext context = new StandardEvaluationContext(rootObject);	×
111	CacheInvokeContext cic = (CacheInvokeContext) rootObject;	×
112	if (parameterNames != null) {	×
113	for (int i = 0; i < parameterNames.length; i++) {	×
114	context.setVariable(parameterNames[i], cic.getArgs()[i]);	×
115	}
116	}
117	context.setVariable("result", cic.getResult());	×
118	return expression.getValue(context);	×
119	}
120	}

alibaba / jetcache / #405

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