30419723982

Committed 29 Jul 2026 03:29AM UTC coverage: 95.429% (-4.5%) from 99.952%

Build # 30419723982

Build Type

Pull #62

github

Committed by

web-flow

Commit Message

Merge 31a86ee9f into 6968676cc

Pull Request Pull Request #62: [Cli] Generate the argument and option parameters a command declares

Coverage Stats

574 of 618 branches covered (92.88%)

Branch coverage included in aggregate %.

93 of 154 new or added lines in 2 files covered. (60.39%)

1618 of 1679 relevant lines covered (96.37%)

4.23 hits per line

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

59.28

/src/main/java/io/sindri/ast/CliRouteParameterReader.java

/*
 * This file is part of the Sindri package.
 *
 * (c) Melech Mizrachi <melechmizrachi@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

package io.sindri.ast;

import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.expr.AnnotationExpr;
import com.github.javaparser.ast.expr.ArrayInitializerExpr;
import com.github.javaparser.ast.expr.Expression;
import com.github.javaparser.ast.expr.MemberValuePair;
import com.github.javaparser.ast.expr.NormalAnnotationExpr;
import com.github.javaparser.ast.expr.SingleMemberAnnotationExpr;
import io.sindri.ast.abstract_.AstReader;
import io.sindri.ast.contract.CliRouteParameterReaderContract;
import io.sindri.ast.data.CliArgumentParameterData;
import io.sindri.ast.data.CliOptionParameterData;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.jspecify.annotations.Nullable;

/**
 * Reads the argument and option parameters a CLI command declares.
 *
 * <p>Each is declared by annotating the command method, and both annotations are repeatable, so a
 * command may carry several of either directly or wrapped in their container annotation.
 */
public class CliRouteParameterReader extends AstReader implements CliRouteParameterReaderContract {

    @Override
    public List<CliArgumentParameterData> updateArguments(
            MethodDeclaration method, Map<String, String> importMap, String pkg) {
        List<CliArgumentParameterData> arguments = new ArrayList<>();

        for (AnnotationExpr annotation : method.getAnnotations()) {
            switch (annotation.getNameAsString()) {
                case "ArgumentParameter" -> addArgument(arguments, annotation);
                case "ArgumentParameters" -> {
                    for (AnnotationExpr inner : extractAnnotationArray(annotation)) {
                        addArgument(arguments, inner);
                    }
                }
                default -> {}
            }
        }

        return arguments;
    }

    @Override
    public List<CliOptionParameterData> updateOptions(
            MethodDeclaration method, Map<String, String> importMap, String pkg) {
        List<CliOptionParameterData> options = new ArrayList<>();

        for (AnnotationExpr annotation : method.getAnnotations()) {
            switch (annotation.getNameAsString()) {
                case "OptionParameter" -> addOption(options, annotation);
                case "OptionParameters" -> {
                    for (AnnotationExpr inner : extractAnnotationArray(annotation)) {
                        addOption(options, inner);
                    }
                }
                default -> {}
            }
        }

        return options;
    }

    private void addArgument(List<CliArgumentParameterData> arguments, AnnotationExpr annotation) {
        CliArgumentParameterData argument = parseArgument(annotation);

        if (argument != null) {
            arguments.add(argument);
        }
    }

    private void addOption(List<CliOptionParameterData> options, AnnotationExpr annotation) {
        CliOptionParameterData option = parseOption(annotation);

        if (option != null) {
            options.add(option);
        }
    }

    private @Nullable CliArgumentParameterData parseArgument(AnnotationExpr annotation) {
        if (!(annotation instanceof NormalAnnotationExpr normal)) {
            return null;
        }

        String name = "";
        String description = "";
        String mode = "OPTIONAL";
        String valueMode = "DEFAULT";

        for (MemberValuePair pair : normal.getPairs()) {
            switch (pair.getNameAsString()) {
                case "name" -> name = extractStringLiteral(pair.getValue());
                case "description" -> description = extractStringLiteral(pair.getValue());
                case "mode" -> mode = extractEnumName(pair.getValue());
                case "valueMode" -> valueMode = extractEnumName(pair.getValue());
                default -> {}
            }
        }

        if (name.isEmpty()) {
            return null;
        }

        return new CliArgumentParameterData(name, description, null, mode, valueMode);
    }

    private @Nullable CliOptionParameterData parseOption(AnnotationExpr annotation) {
        if (!(annotation instanceof NormalAnnotationExpr normal)) {
            return null;
        }

        String name = "";
        String description = "";
        String valueDisplayName = "";
        String defaultValue = "";
        List<String> shortNames = List.of();
        List<String> validValues = List.of();
        String mode = "OPTIONAL";
        String valueMode = "DEFAULT";

        for (MemberValuePair pair : normal.getPairs()) {
            switch (pair.getNameAsString()) {
                case "name" -> name = extractStringLiteral(pair.getValue());
                case "description" -> description = extractStringLiteral(pair.getValue());
                case "valueDisplayName" -> valueDisplayName = extractStringLiteral(pair.getValue());
                case "defaultValue" -> defaultValue = extractStringLiteral(pair.getValue());
                case "shortNames" -> shortNames = extractStringArray(pair.getValue());
                case "validValues" -> validValues = extractStringArray(pair.getValue());
                case "mode" -> mode = extractEnumName(pair.getValue());
                case "valueMode" -> valueMode = extractEnumName(pair.getValue());
                default -> {}
            }
        }

        if (name.isEmpty()) {
            return null;
        }

        return new CliOptionParameterData(
                name,
                description,
                valueDisplayName,
                null,
                defaultValue,
                shortNames,
                validValues,
                mode,
                valueMode);
    }

    /** Extract the annotations a container annotation wraps in its {@code value} member. */
    private List<AnnotationExpr> extractAnnotationArray(AnnotationExpr annotation) {
        Expression value = null;

        if (annotation instanceof SingleMemberAnnotationExpr single) {
            value = single.getMemberValue();
        } else if (annotation instanceof NormalAnnotationExpr normal) {
            for (MemberValuePair pair : normal.getPairs()) {
                if (pair.getNameAsString().equals("value")) {
                    value = pair.getValue();
                }
            }
        }

        List<AnnotationExpr> result = new ArrayList<>();

        if (value instanceof ArrayInitializerExpr array) {
            for (Expression item : array.getValues()) {
                if (item instanceof AnnotationExpr inner) {
                    result.add(inner);
                }
            }
        } else if (value instanceof AnnotationExpr inner) {
            result.add(inner);
        }

        return result;
    }

    /** Extract a string array member, which may also be written as a single string. */
    private List<String> extractStringArray(Expression expr) {
        List<String> values = new ArrayList<>();

        if (expr.isArrayInitializerExpr()) {
            for (Expression value : expr.asArrayInitializerExpr().getValues()) {
                values.add(extractStringLiteral(value));
            }

            return values;
        }

        values.add(extractStringLiteral(expr));

        return values;
    }

    /** Extract an enum member's case name, e.g. {@code REQUIRED} from {@code Mode.REQUIRED}. */
    private String extractEnumName(Expression expr) {
        if (expr.isFieldAccessExpr()) {
            return expr.asFieldAccessExpr().getNameAsString();
        }

        if (expr.isNameExpr()) {
            return expr.asNameExpr().getNameAsString();
        }

        return expr.toString();
    }
}

1	/*
2	* This file is part of the Sindri package.
3	*
4	* (c) Melech Mizrachi <melechmizrachi@gmail.com>
5	*
6	* For the full copyright and license information, please view the LICENSE
7	* file that was distributed with this source code.
8	*/
9
10	package io.sindri.ast;
11
12	import com.github.javaparser.ast.body.MethodDeclaration;
13	import com.github.javaparser.ast.expr.AnnotationExpr;
14	import com.github.javaparser.ast.expr.ArrayInitializerExpr;
15	import com.github.javaparser.ast.expr.Expression;
16	import com.github.javaparser.ast.expr.MemberValuePair;
17	import com.github.javaparser.ast.expr.NormalAnnotationExpr;
18	import com.github.javaparser.ast.expr.SingleMemberAnnotationExpr;
19	import io.sindri.ast.abstract_.AstReader;
20	import io.sindri.ast.contract.CliRouteParameterReaderContract;
21	import io.sindri.ast.data.CliArgumentParameterData;
22	import io.sindri.ast.data.CliOptionParameterData;
23	import java.util.ArrayList;
24	import java.util.List;
25	import java.util.Map;
26	import org.jspecify.annotations.Nullable;
27
28	/**
29	* Reads the argument and option parameters a CLI command declares.
30	*
31	* <p>Each is declared by annotating the command method, and both annotations are repeatable, so a
32	* command may carry several of either directly or wrapped in their container annotation.
33	*/
34	public class CliRouteParameterReader extends AstReader implements CliRouteParameterReaderContract {	3✔
35
36	@Override
37	public List<CliArgumentParameterData> updateArguments(
38	MethodDeclaration method, Map<String, String> importMap, String pkg) {
39	List<CliArgumentParameterData> arguments = new ArrayList<>();	4✔
40
41	for (AnnotationExpr annotation : method.getAnnotations()) {	11✔
42	switch (annotation.getNameAsString()) {	9!
43	case "ArgumentParameter" -> addArgument(arguments, annotation);	5✔
44	case "ArgumentParameters" -> {
NEW 45	for (AnnotationExpr inner : extractAnnotationArray(annotation)) {	×
NEW 46	addArgument(arguments, inner);	×
NEW 47	}	×
NEW 48	}	×
49	default -> {}
50	}
51	}	1✔
52
53	return arguments;	2✔
54	}
55
56	@Override
57	public List<CliOptionParameterData> updateOptions(
58	MethodDeclaration method, Map<String, String> importMap, String pkg) {
59	List<CliOptionParameterData> options = new ArrayList<>();	4✔
60
61	for (AnnotationExpr annotation : method.getAnnotations()) {	11✔
62	switch (annotation.getNameAsString()) {	9!
63	case "OptionParameter" -> addOption(options, annotation);	5✔
64	case "OptionParameters" -> {
NEW 65	for (AnnotationExpr inner : extractAnnotationArray(annotation)) {	×
NEW 66	addOption(options, inner);	×
NEW 67	}	×
NEW 68	}	×
69	default -> {}
70	}
71	}	1✔
72
73	return options;	2✔
74	}
75
76	private void addArgument(List<CliArgumentParameterData> arguments, AnnotationExpr annotation) {
77	CliArgumentParameterData argument = parseArgument(annotation);	4✔
78
79	if (argument != null) {	2!
80	arguments.add(argument);	4✔
81	}
82	}	1✔
83
84	private void addOption(List<CliOptionParameterData> options, AnnotationExpr annotation) {
85	CliOptionParameterData option = parseOption(annotation);	4✔
86
87	if (option != null) {	2!
88	options.add(option);	4✔
89	}
90	}	1✔
91
92	private @Nullable CliArgumentParameterData parseArgument(AnnotationExpr annotation) {
93	if (!(annotation instanceof NormalAnnotationExpr normal)) {	7!
NEW 94	return null;	×
95	}
96
97	String name = "";	2✔
98	String description = "";	2✔
99	String mode = "OPTIONAL";	2✔
100	String valueMode = "DEFAULT";	2✔
101
102	for (MemberValuePair pair : normal.getPairs()) {	11✔
103	switch (pair.getNameAsString()) {	9!
104	case "name" -> name = extractStringLiteral(pair.getValue());	6✔
105	case "description" -> description = extractStringLiteral(pair.getValue());	6✔
106	case "mode" -> mode = extractEnumName(pair.getValue());	6✔
107	case "valueMode" -> valueMode = extractEnumName(pair.getValue());	6✔
108	default -> {}
109	}
110	}	1✔
111
112	if (name.isEmpty()) {	3!
NEW 113	return null;	×
114	}
115
116	return new CliArgumentParameterData(name, description, null, mode, valueMode);	9✔
117	}
118
119	private @Nullable CliOptionParameterData parseOption(AnnotationExpr annotation) {
120	if (!(annotation instanceof NormalAnnotationExpr normal)) {	7!
NEW 121	return null;	×
122	}
123
124	String name = "";	2✔
125	String description = "";	2✔
126	String valueDisplayName = "";	2✔
127	String defaultValue = "";	2✔
128	List<String> shortNames = List.of();	2✔
129	List<String> validValues = List.of();	2✔
130	String mode = "OPTIONAL";	2✔
131	String valueMode = "DEFAULT";	2✔
132
133	for (MemberValuePair pair : normal.getPairs()) {	11✔
134	switch (pair.getNameAsString()) {	9!
135	case "name" -> name = extractStringLiteral(pair.getValue());	6✔
136	case "description" -> description = extractStringLiteral(pair.getValue());	6✔
137	case "valueDisplayName" -> valueDisplayName = extractStringLiteral(pair.getValue());	6✔
138	case "defaultValue" -> defaultValue = extractStringLiteral(pair.getValue());	6✔
139	case "shortNames" -> shortNames = extractStringArray(pair.getValue());	6✔
140	case "validValues" -> validValues = extractStringArray(pair.getValue());	6✔
141	case "mode" -> mode = extractEnumName(pair.getValue());	6✔
142	case "valueMode" -> valueMode = extractEnumName(pair.getValue());	6✔
143	default -> {}
144	}
145	}	1✔
146
147	if (name.isEmpty()) {	3!
NEW 148	return null;	×
149	}
150
151	return new CliOptionParameterData(	13✔
152	name,
153	description,
154	valueDisplayName,
155	null,
156	defaultValue,
157	shortNames,
158	validValues,
159	mode,
160	valueMode);
161	}
162
163	/** Extract the annotations a container annotation wraps in its {@code value} member. */
164	private List<AnnotationExpr> extractAnnotationArray(AnnotationExpr annotation) {
NEW 165	Expression value = null;	×
166
NEW 167	if (annotation instanceof SingleMemberAnnotationExpr single) {	×
NEW 168	value = single.getMemberValue();	×
NEW 169	} else if (annotation instanceof NormalAnnotationExpr normal) {	×
NEW 170	for (MemberValuePair pair : normal.getPairs()) {	×
NEW 171	if (pair.getNameAsString().equals("value")) {	×
NEW 172	value = pair.getValue();	×
173	}
NEW 174	}	×
175	}
176
NEW 177	List<AnnotationExpr> result = new ArrayList<>();	×
178
NEW 179	if (value instanceof ArrayInitializerExpr array) {	×
NEW 180	for (Expression item : array.getValues()) {	×
NEW 181	if (item instanceof AnnotationExpr inner) {	×
NEW 182	result.add(inner);	×
183	}
NEW 184	}	×
NEW 185	} else if (value instanceof AnnotationExpr inner) {	×
NEW 186	result.add(inner);	×
187	}
188
NEW 189	return result;	×
190	}
191
192	/** Extract a string array member, which may also be written as a single string. */
193	private List<String> extractStringArray(Expression expr) {
194	List<String> values = new ArrayList<>();	4✔
195
196	if (expr.isArrayInitializerExpr()) {	3!
197	for (Expression value : expr.asArrayInitializerExpr().getValues()) {	12✔
198	values.add(extractStringLiteral(value));	6✔
199	}	1✔
200
201	return values;	2✔
202	}
203
NEW 204	values.add(extractStringLiteral(expr));	×
205
NEW 206	return values;	×
207	}
208
209	/** Extract an enum member's case name, e.g. {@code REQUIRED} from {@code Mode.REQUIRED}. */
210	private String extractEnumName(Expression expr) {
211	if (expr.isFieldAccessExpr()) {	3!
212	return expr.asFieldAccessExpr().getNameAsString();	4✔
213	}
214
NEW 215	if (expr.isNameExpr()) {	×
NEW 216	return expr.asNameExpr().getNameAsString();	×
217	}
218
NEW 219	return expr.toString();	×
220	}
221	}

valkyrjaio / sindri-java / 30419723982

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