17263397398

Committed 27 Aug 2025 09:52AM UTC coverage: 12.405% (-0.05%) from 12.455%

Build # 17263397398

Build Type

push

github

Committed by

tkuhn

Commit Message

Support for literal datatypes/language tags in literal placeholders

Run Details

332 of 3820 branches covered (8.69%)

Branch coverage included in aggregate %.

989 of 6829 relevant lines covered (14.48%)

0.64 hits per line

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

0.0

src/main/java/com/knowledgepixels/nanodash/component/LiteralTextfieldItem.java

package com.knowledgepixels.nanodash.component;

import com.knowledgepixels.nanodash.Utils;
import com.knowledgepixels.nanodash.template.Template;
import com.knowledgepixels.nanodash.template.TemplateContext;
import com.knowledgepixels.nanodash.template.UnificationException;
import org.apache.wicket.AttributeModifier;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.form.AbstractTextComponent;
import org.apache.wicket.markup.html.form.TextField;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.IModel;
import org.apache.wicket.model.Model;
import org.apache.wicket.validation.IValidatable;
import org.apache.wicket.validation.IValidator;
import org.apache.wicket.validation.ValidationError;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Literal;
import org.eclipse.rdf4j.model.Value;
import org.eclipse.rdf4j.model.util.Literals;

/**
 * A component that represents a text field for entering literal values.
 */
public class LiteralTextfieldItem extends Panel implements ContextComponent {

    private static final long serialVersionUID = 1L;
    private TemplateContext context;
    private AbstractTextComponent<String> textfield;
    private Label languageComp, datatypeComp;
    private IModel<String> languageModel, datatypeModel;
    private final String regex;
    private final IRI iri;

    /**
     * Constructs a LiteralTextfieldItem with the specified ID, IRI, optional flag, and template context.
     *
     * @param id       the component ID
     * @param iri      the IRI associated with this text field
     * @param optional whether this field is optional
     * @param context  the template context containing models and parameters
     */
    public LiteralTextfieldItem(String id, final IRI iri, boolean optional, TemplateContext context) {
        super(id);
        this.context = context;
        final Template template = context.getTemplate();
        this.iri = iri;
        regex = template.getRegex(iri);
        IModel<String> model = context.getComponentModels().get(iri);
        if (model == null) {
            model = Model.of("");
            context.getComponentModels().put(iri, model);
        }
        String postfix = Utils.getUriPostfix(iri);
        if (context.hasParam(postfix)) {
            model.setObject(context.getParam(postfix));
        }
        AbstractTextComponent<String> tc = initTextComponent(model);
        if (!optional) tc.setRequired(true);
        if (context.getTemplate().getLabel(iri) != null) {
            tc.add(new AttributeModifier("placeholder", context.getTemplate().getLabel(iri)));
        }
        tc.add(new IValidator<String>() {

            private static final long serialVersionUID = 1L;

            @Override
            public void validate(IValidatable<String> s) {
                if (regex != null) {
                    if (!s.getValue().matches(regex)) {
                        s.error(new ValidationError("Value '" + s.getValue() + "' doesn't match the pattern '" + regex + "'"));
                    }
                }
            }

        });
        context.getComponentModels().put(iri, tc.getModel());
        context.getComponents().add(tc);
        tc.add(new ValueItem.KeepValueAfterRefreshBehavior());
        tc.add(new InvalidityHighlighting());
        add(tc);

        languageModel = Model.of("");
        languageComp = new Label("language", languageModel);
        datatypeModel = Model.of("");
        datatypeComp = new Label("datatype", datatypeModel);
        if (template.getLanguageTag(iri) != null) {
            languageModel.setObject("(" + template.getLanguageTag(iri) + ")");
            datatypeComp.setVisible(false);
        } else if (template.getDatatype(iri) != null && !template.getDatatype(iri).stringValue().equals("http://www.w3.org/2001/XMLSchema#string")) {
            datatypeModel.setObject("(" + template.getDatatype(iri).stringValue().replace("http://www.w3.org/2001/XMLSchema#", "xsd:") + ")");
            languageComp.setVisible(false);
        } else {
            datatypeComp.setVisible(false);
            languageComp.setVisible(false);
        }
        add(languageComp);
        add(datatypeComp);
    }

    /**
     * <p>initTextComponent.</p>
     *
     * @param model a {@link org.apache.wicket.model.IModel} object
     * @return a {@link org.apache.wicket.markup.html.form.AbstractTextComponent} object
     */
    protected AbstractTextComponent<String> initTextComponent(IModel<String> model) {
        textfield = new TextField<>("textfield", model);
        return textfield;
    }

    /**
     * <p>getTextComponent.</p>
     *
     * @return a {@link org.apache.wicket.markup.html.form.AbstractTextComponent} object
     */
    protected AbstractTextComponent<String> getTextComponent() {
        return textfield;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void removeFromContext() {
        context.getComponents().remove(getTextComponent());
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isUnifiableWith(Value v) {
        if (v == null) return true;
        if (v instanceof Literal vL) {
            if (regex != null && !vL.stringValue().matches(regex)) {
                return false;
            }
            if (getTextComponent().getModelObject().isEmpty()) {
                return true;
            }
            String languagetag = context.getTemplate().getLanguageTag(iri);
            IRI datatype = context.getTemplate().getDatatype(iri);
            if (languagetag != null) {
                if (!vL.getLanguage().isPresent() || !Literals.normalizeLanguageTag(vL.getLanguage().get()).equals(languagetag)) {
                    return false;
                }
            } else if (datatype != null) {
                if (!vL.getDatatype().equals(datatype)) {
                    return false;
                }
            }
            return vL.stringValue().equals(getTextComponent().getModelObject());
        }
        return false;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void unifyWith(Value v) throws UnificationException {
        if (v == null) return;
        if (!isUnifiableWith(v)) throw new UnificationException(v.stringValue());
        Literal vL = (Literal) v;
        getTextComponent().setModelObject(vL.stringValue());
        if (vL.getLanguage().isPresent()) {
            languageModel.setObject("(" + vL.getLanguage().get().toLowerCase() + ")");
            languageComp.setVisible(true);
        } else if (!vL.getDatatype().stringValue().equals("http://www.w3.org/2001/XMLSchema#string")) {
            datatypeModel.setObject("(" + vL.getDatatype().stringValue().replace("http://www.w3.org/2001/XMLSchema#", "xsd:") + ")");
            datatypeComp.setVisible(true);
        }

        getTextComponent().setModelObject(v.stringValue());
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void fillFinished() {
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void finalizeValues() {
        Value defaultValue = context.getTemplate().getDefault(iri);
        if (isUnifiableWith(defaultValue)) {
            try {
                unifyWith(defaultValue);
            } catch (UnificationException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String toString() {
        return "[Literal textfield item]";
    }

}

1	package com.knowledgepixels.nanodash.component;
2
3	import com.knowledgepixels.nanodash.Utils;
4	import com.knowledgepixels.nanodash.template.Template;
5	import com.knowledgepixels.nanodash.template.TemplateContext;
6	import com.knowledgepixels.nanodash.template.UnificationException;
7	import org.apache.wicket.AttributeModifier;
8	import org.apache.wicket.markup.html.basic.Label;
9	import org.apache.wicket.markup.html.form.AbstractTextComponent;
10	import org.apache.wicket.markup.html.form.TextField;
11	import org.apache.wicket.markup.html.panel.Panel;
12	import org.apache.wicket.model.IModel;
13	import org.apache.wicket.model.Model;
14	import org.apache.wicket.validation.IValidatable;
15	import org.apache.wicket.validation.IValidator;
16	import org.apache.wicket.validation.ValidationError;
17	import org.eclipse.rdf4j.model.IRI;
18	import org.eclipse.rdf4j.model.Literal;
19	import org.eclipse.rdf4j.model.Value;
20	import org.eclipse.rdf4j.model.util.Literals;
21
22	/**
23	* A component that represents a text field for entering literal values.
24	*/
25	public class LiteralTextfieldItem extends Panel implements ContextComponent {
26
27	private static final long serialVersionUID = 1L;
28	private TemplateContext context;
29	private AbstractTextComponent<String> textfield;
30	private Label languageComp, datatypeComp;
31	private IModel<String> languageModel, datatypeModel;
32	private final String regex;
33	private final IRI iri;
34
35	/**
36	* Constructs a LiteralTextfieldItem with the specified ID, IRI, optional flag, and template context.
37	*
38	* @param id the component ID
39	* @param iri the IRI associated with this text field
40	* @param optional whether this field is optional
41	* @param context the template context containing models and parameters
42	*/
43	public LiteralTextfieldItem(String id, final IRI iri, boolean optional, TemplateContext context) {
44	super(id);	×
45	this.context = context;	×
46	final Template template = context.getTemplate();	×
47	this.iri = iri;	×
48	regex = template.getRegex(iri);	×
49	IModel<String> model = context.getComponentModels().get(iri);	×
50	if (model == null) {	×
51	model = Model.of("");	×
52	context.getComponentModels().put(iri, model);	×
53	}
54	String postfix = Utils.getUriPostfix(iri);	×
55	if (context.hasParam(postfix)) {	×
56	model.setObject(context.getParam(postfix));	×
57	}
58	AbstractTextComponent<String> tc = initTextComponent(model);	×
59	if (!optional) tc.setRequired(true);	×
60	if (context.getTemplate().getLabel(iri) != null) {	×
61	tc.add(new AttributeModifier("placeholder", context.getTemplate().getLabel(iri)));	×
62	}
63	tc.add(new IValidator<String>() {	×
64
65	private static final long serialVersionUID = 1L;
66
67	@Override
68	public void validate(IValidatable<String> s) {
69	if (regex != null) {	×
70	if (!s.getValue().matches(regex)) {	×
71	s.error(new ValidationError("Value '" + s.getValue() + "' doesn't match the pattern '" + regex + "'"));	×
72	}
73	}
74	}	×
75
76	});
77	context.getComponentModels().put(iri, tc.getModel());	×
78	context.getComponents().add(tc);	×
79	tc.add(new ValueItem.KeepValueAfterRefreshBehavior());	×
80	tc.add(new InvalidityHighlighting());	×
81	add(tc);	×
82
83	languageModel = Model.of("");	×
84	languageComp = new Label("language", languageModel);	×
85	datatypeModel = Model.of("");	×
86	datatypeComp = new Label("datatype", datatypeModel);	×
87	if (template.getLanguageTag(iri) != null) {	×
88	languageModel.setObject("(" + template.getLanguageTag(iri) + ")");	×
89	datatypeComp.setVisible(false);	×
90	} else if (template.getDatatype(iri) != null && !template.getDatatype(iri).stringValue().equals("http://www.w3.org/2001/XMLSchema#string")) {	×
91	datatypeModel.setObject("(" + template.getDatatype(iri).stringValue().replace("http://www.w3.org/2001/XMLSchema#", "xsd:") + ")");	×
92	languageComp.setVisible(false);	×
93	} else {
94	datatypeComp.setVisible(false);	×
95	languageComp.setVisible(false);	×
96	}
97	add(languageComp);	×
98	add(datatypeComp);	×
99	}	×
100
101	/**
102	* <p>initTextComponent.</p>
103	*
104	* @param model a {@link org.apache.wicket.model.IModel} object
105	* @return a {@link org.apache.wicket.markup.html.form.AbstractTextComponent} object
106	*/
107	protected AbstractTextComponent<String> initTextComponent(IModel<String> model) {
108	textfield = new TextField<>("textfield", model);	×
109	return textfield;	×
110	}
111
112	/**
113	* <p>getTextComponent.</p>
114	*
115	* @return a {@link org.apache.wicket.markup.html.form.AbstractTextComponent} object
116	*/
117	protected AbstractTextComponent<String> getTextComponent() {
118	return textfield;	×
119	}
120
121	/**
122	* {@inheritDoc}
123	*/
124	@Override
125	public void removeFromContext() {
126	context.getComponents().remove(getTextComponent());	×
127	}	×
128
129	/**
130	* {@inheritDoc}
131	*/
132	@Override
133	public boolean isUnifiableWith(Value v) {
134	if (v == null) return true;	×
135	if (v instanceof Literal vL) {	×
136	if (regex != null && !vL.stringValue().matches(regex)) {	×
137	return false;	×
138	}
139	if (getTextComponent().getModelObject().isEmpty()) {	×
140	return true;	×
141	}
142	String languagetag = context.getTemplate().getLanguageTag(iri);	×
143	IRI datatype = context.getTemplate().getDatatype(iri);	×
144	if (languagetag != null) {	×
145	if (!vL.getLanguage().isPresent() \|\| !Literals.normalizeLanguageTag(vL.getLanguage().get()).equals(languagetag)) {	×
146	return false;	×
147	}
148	} else if (datatype != null) {	×
149	if (!vL.getDatatype().equals(datatype)) {	×
150	return false;	×
151	}
152	}
153	return vL.stringValue().equals(getTextComponent().getModelObject());	×
154	}
155	return false;	×
156	}
157
158	/**
159	* {@inheritDoc}
160	*/
161	@Override
162	public void unifyWith(Value v) throws UnificationException {
163	if (v == null) return;	×
164	if (!isUnifiableWith(v)) throw new UnificationException(v.stringValue());	×
165	Literal vL = (Literal) v;	×
166	getTextComponent().setModelObject(vL.stringValue());	×
167	if (vL.getLanguage().isPresent()) {	×
168	languageModel.setObject("(" + vL.getLanguage().get().toLowerCase() + ")");	×
169	languageComp.setVisible(true);	×
170	} else if (!vL.getDatatype().stringValue().equals("http://www.w3.org/2001/XMLSchema#string")) {	×
171	datatypeModel.setObject("(" + vL.getDatatype().stringValue().replace("http://www.w3.org/2001/XMLSchema#", "xsd:") + ")");	×
172	datatypeComp.setVisible(true);	×
173	}
174
175	getTextComponent().setModelObject(v.stringValue());	×
176	}	×
177
178	/**
179	* {@inheritDoc}
180	*/
181	@Override
182	public void fillFinished() {
183	}	×
184
185	/**
186	* {@inheritDoc}
187	*/
188	@Override
189	public void finalizeValues() {
190	Value defaultValue = context.getTemplate().getDefault(iri);	×
191	if (isUnifiableWith(defaultValue)) {	×
192	try {
193	unifyWith(defaultValue);	×
194	} catch (UnificationException ex) {	×
195	ex.printStackTrace();	×
196	}	×
197	}
198	}	×
199
200	/**
201	* {@inheritDoc}
202	*/
203	@Override
204	public String toString() {
205	return "[Literal textfield item]";	×
206	}
207
208	}

knowledgepixels / nanodash / 17263397398

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