feat: initial implementation

Author: javier-godoy

README.md

@@ -1,24 +1,27 @@
-[![Published on Vaadin Directory](https://img.shields.io/badge/Vaadin%20Directory-published-00b4f0.svg)](https://vaadin.com/directory/component/template-add-on)
-[![Stars on vaadin.com/directory](https://img.shields.io/vaadin-directory/star/template-add-on.svg)](https://vaadin.com/directory/component/template-add-on)
-[![Build Status](https://jenkins.flowingcode.com/job/template-addon/badge/icon)](https://jenkins.flowingcode.com/job/template-addon)
-[![Maven Central](https://img.shields.io/maven-central/v/com.flowingcode.vaadin.addons/template-addon)](https://mvnrepository.com/artifact/com.flowingcode.vaadin.addons/template-addon)
-[![Javadoc](https://img.shields.io/badge/javadoc-00b4f0)](https://javadoc.flowingcode.com/artifact/com.flowingcode.vaadin.addons/template-addon)
+[![Published on Vaadin Directory](https://img.shields.io/badge/Vaadin%20Directory-published-00b4f0.svg)](https://vaadin.com/directory/component/regular-expression-field-add-on)
+[![Stars on vaadin.com/directory](https://img.shields.io/vaadin-directory/star/regular-expression-field-add-on.svg)](https://vaadin.com/directory/component/regular-expression-field-add-on)
+[![Build Status](https://jenkins.flowingcode.com/job/regular-expression-field-addon/badge/icon)](https://jenkins.flowingcode.com/job/regular-expression-field-addon)
+[![Maven Central](https://img.shields.io/maven-central/v/com.flowingcode.vaadin.addons/regular-expression-field-addon)](https://mvnrepository.com/artifact/com.flowingcode.vaadin.addons/regular-expression-field-addon)
+[![Javadoc](https://img.shields.io/badge/javadoc-00b4f0)](https://javadoc.flowingcode.com/artifact/com.flowingcode.vaadin.addons/regular-expression-field-addon)
 
-# Template Add-on
+# Regular Expression Field Add-on
 
-This is a template project for building new Vaadin 24 add-ons
+A field for Vaadin 24 that assists in creating regular expressions.
 
 ## Features
 
-* List the features of your add-on in here
+* A ComboBox option for creating simple regular expressions, such as "contains."
+* Additional options for patterns like "starts with" and "ends with."
+* An advanced mode that assists in creating complex regular expressions with automatic validation.
+
 
 ## Online demo
 
-[Online demo here](http://addonsv24.flowingcode.com/template)
+[Online demo here](http://addonsv24.flowingcode.com/regular-expression-field)
 
 ## Download release
 
-[Available in Vaadin Directory](https://vaadin.com/directory/component/template-add-on)
+[Available in Vaadin Directory](https://vaadin.com/directory/component/regular-expression-field-add-on)
 
 ### Maven install
 
@@ -27,7 +30,7 @@ Add the following dependencies in your pom.xml file:
 ```xml
 <dependency>
    <groupId>com.flowingcode.vaadin.addons</groupId>
-   <artifactId>template-addon</artifactId>
+   <artifactId>regular-expression-field-addon</artifactId>
    <version>X.Y.Z</version>
 </dependency>
 ```
@@ -69,7 +72,7 @@ Then, follow these steps for creating a contribution:
 
 This add-on is distributed under Apache License 2.0. For license terms, see LICENSE.txt.
 
-TEMPLATE_ADDON is written by Flowing Code S.A.
+Regular Expression Field Add-On is written by Flowing Code S.A.
 
 # Developer Guide
 

pom.xml

@@ -5,14 +5,14 @@
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>com.flowingcode.vaadin.addons</groupId>
-    <artifactId>template-addon</artifactId>
+    <artifactId>regular-expression-field-addon</artifactId>
     <version>1.0.0-SNAPSHOT</version>
-    <name>Template Add-on</name>
-    <description>Template Add-on for Vaadin Flow</description>
+    <name>Regular Expression Field Add-on</name>
+    <description>Regular Expression Field Add-on for Vaadin Flow</description>
     <url>https://www.flowingcode.com/en/open-source/</url>
 
     <properties>
-        <vaadin.version>24.4.6</vaadin.version>
+        <vaadin.version>24.7.0</vaadin.version>
         <selenium.version>4.10.0</selenium.version>
         <maven.compiler.source>17</maven.compiler.source>
         <maven.compiler.target>17</maven.compiler.target>
@@ -21,7 +21,6 @@
         <drivers.dir>${project.basedir}/drivers</drivers.dir>
         <jetty.version>11.0.20</jetty.version>
         <flowingcode.commons.demo.version>4.2.0</flowingcode.commons.demo.version>
-        <frontend.hotdeploy>true</frontend.hotdeploy>
     </properties>
 
     <organization>
@@ -122,6 +121,12 @@
             <artifactId>vaadin-core</artifactId>
             <optional>true</optional>
         </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.36</version>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.flowingcode.vaadin.addons.demo</groupId>
             <artifactId>commons-demo</artifactId>
@@ -264,15 +269,12 @@
                     <scan>3</scan>
                     <!-- Use test scope because the UI/demo classes are in the test package. -->
                     <useTestScope>true</useTestScope>
-                    <webApp>
-                        <resourceBases>
-                            <resourceBase>src/test/resources/META-INF/resources</resourceBase>
-                            <resourceBase>src/main/resources/META-INF/resources</resourceBase>
-                        </resourceBases>
-                    </webApp>
                     <supportedPackagings>
                         <supportedPackaging>jar</supportedPackaging>
                     </supportedPackagings>
+                    <systemProperties>
+                        <vaadin.frontend.hotdeploy>true</vaadin.frontend.hotdeploy>
+                    </systemProperties>
                 </configuration>
             </plugin>
         </plugins>

src/main/java/com/flowingcode/vaadin/addons/regex/RegularExpression.java

@@ -0,0 +1,129 @@
+/*-
+ * #%L
+ * Regular Expression Field Add-on
+ * %%
+ * Copyright (C) 2025 Flowing Code
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+package com.flowingcode.vaadin.addons.regex;
+
+import static com.flowingcode.vaadin.addons.regex.RegularExpressionOperator.ADVANCED;
+import static com.flowingcode.vaadin.addons.regex.RegularExpressionOperator.CONTAINS;
+import static com.flowingcode.vaadin.addons.regex.RegularExpressionOperator.ENDS_WITH;
+import static com.flowingcode.vaadin.addons.regex.RegularExpressionOperator.STARTS_WITH;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.Setter;
+
+@Getter
+@Setter
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+/**
+ *
+ * @author Javier Godoy
+ */
+public final class RegularExpression {
+
+  private static final String ANY = ".*";
+
+  @EqualsAndHashCode.Include
+  private final RegularExpressionOperator operator;
+
+  @EqualsAndHashCode.Include
+  private final String input;
+
+  private final Pattern pattern;
+
+  public RegularExpression(@NonNull RegularExpressionOperator operator, @NonNull String input)
+      throws PatternSyntaxException {
+    this.operator = operator;
+    this.input = input;
+
+    String regex = switch (operator) {
+      case ADVANCED -> input;
+      case CONTAINS -> ANY + quote(input) + ANY;
+      case ENDS_WITH -> ANY + quote(input);
+      case STARTS_WITH -> quote(input) + ANY;
+    };
+
+    pattern = Pattern.compile(regex);
+  }
+
+  private final static String CHARS = ".?+*\\[({$^|\\\\";
+
+  private final static Pattern SIMPLE_PATTERN =
+      Pattern.compile("(?:[^CHARS]|\\\\[CHARS])+".replace("CHARS", CHARS));
+
+  private final static Pattern ESCAPE_PATTERN =
+      Pattern.compile("[CHARS]".replace("CHARS", CHARS));
+
+  private final static Pattern UNQUOTE_PATTERN =
+      Pattern.compile("\\\\([CHARS])".replace("CHARS", CHARS));
+
+  private static String quote(String input) {
+    String s1 = ESCAPE_PATTERN.matcher(input).replaceAll("\\\\$0");
+    String s2 = "\\Q" + input.replace("\\E", "\\E\\\\E\\Q") + "\\E";
+    return (s1.length() < s2.length()) ? s1 : s2;
+  }
+
+  public static RegularExpression of(Pattern pattern) {
+
+    String regex = pattern.pattern();
+    boolean notStartsWith = false;
+    boolean notEndsWith = false;
+    if (regex.startsWith(ANY)) {
+      notStartsWith = true;
+      regex = regex.substring(2);
+    }
+
+    if (regex.endsWith(ANY)) {
+      notEndsWith = true;
+      regex = regex.substring(0, regex.length() - 2);
+    }
+
+    String input = null;
+    if (notStartsWith || notEndsWith) {
+      if (SIMPLE_PATTERN.matcher(regex).matches()) {
+        input = UNQUOTE_PATTERN.matcher(regex).replaceAll("$1");
+      } else if (regex.startsWith("\\Q") && regex.endsWith("\\E")) {
+        input = regex.substring(2, regex.length() - 2).replace("\\E\\\\E\\Q", "\\E");
+      }
+    }
+
+    if (input != null) {
+      if (notStartsWith && notEndsWith) {
+        return new RegularExpression(CONTAINS, input);
+      } else if (notStartsWith) {
+        return new RegularExpression(ENDS_WITH, input);
+      } else if (notEndsWith) {
+        return new RegularExpression(STARTS_WITH, input);
+      }
+    }
+
+      return new RegularExpression(ADVANCED, pattern.pattern(), pattern);
+  }
+
+  @Override
+  public String toString() {
+    return operator + " " + input;
+  }
+
+}

src/main/java/com/flowingcode/vaadin/addons/regex/RegularExpressionField.java

@@ -0,0 +1,122 @@
+/*-
+ * #%L
+ * Regular Expression Field Add-on
+ * %%
+ * Copyright (C) 2025 Flowing Code
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+package com.flowingcode.vaadin.addons.regex;
+
+import com.vaadin.flow.component.customfield.CustomField;
+import com.vaadin.flow.component.orderedlayout.HorizontalLayout;
+import com.vaadin.flow.component.select.Select;
+import com.vaadin.flow.component.textfield.TextField;
+import java.util.Collection;
+import java.util.regex.PatternSyntaxException;
+
+@SuppressWarnings("serial")
+/**
+ *
+ * @author Javier Godoy
+ */
+public class RegularExpressionField extends CustomField<RegularExpression> {
+
+  private final Select<RegularExpressionOperator> operatorField;
+
+  private final TextField inputField;
+
+  private final RegularExpressionTestField testField;
+
+  private boolean hasPatternSyntaxError;
+
+  private boolean testFieldEnabled;
+
+  public RegularExpressionField() {
+    operatorField = new Select<>();
+    operatorField.setItems(RegularExpressionOperator.values());
+    inputField = new TextField();
+
+    testField = new RegularExpressionTestField();
+    testField.setVisible(false);
+    add(new HorizontalLayout(operatorField, inputField), testField);
+
+    operatorField.addValueChangeListener(ev -> setTestFieldEnabled(testFieldEnabled));
+    addValueChangeListener(ev -> testField.setPattern(getValue()));
+  }
+
+  @Override
+  protected RegularExpression generateModelValue() {
+    if (hasPatternSyntaxError) {
+      onPatternSyntaxException(null, 0);
+      hasPatternSyntaxError = false;
+    }
+    if (!inputField.isEmpty() && !operatorField.isEmpty()) {
+      try {
+        var r = new RegularExpression(operatorField.getValue(), inputField.getValue());
+        return r;
+      } catch (PatternSyntaxException e) {
+        onPatternSyntaxException(e.getDescription(), e.getIndex());
+        hasPatternSyntaxError = true;
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+
+  private void onPatternSyntaxException(String description, int index) {
+    String errorMessage = description;
+    if (description != null && index >= 0) {
+      errorMessage += " near index " + index;
+    }
+    setErrorMessage(errorMessage);
+    inputField.setInvalid(errorMessage != null);
+    setInvalid(errorMessage != null);
+  }
+
+  @Override
+  protected void setPresentationValue(RegularExpression newPresentationValue) {
+    inputField.setValue(newPresentationValue.getInput());
+    operatorField.setValue(newPresentationValue.getOperator());
+  }
+
+  @Override
+  public boolean isInvalid() {
+    return super.isInvalid() || inputField.isInvalid();
+  }
+
+  public void setTestFieldEnabled(boolean enabled) {
+    testFieldEnabled = enabled;
+    testField.setVisible(
+        testFieldEnabled && operatorField.getValue() == RegularExpressionOperator.ADVANCED);
+  }
+
+  public boolean isTestFieldEnabled() {
+    return testFieldEnabled;
+  }
+
+  public void setOperator(RegularExpressionOperator operator) {
+    operatorField.setValue(operator);
+  }
+
+  public void setTestStrings(String... strings) {
+    testField.setItems(strings);
+  }
+
+  public void setTestStrings(Collection<String> strings) {
+    testField.setItems(strings);
+  }
+
+}