Editor search type dropdown menu

vassal-app/src/main/java/VASSAL/configure/ConfigureTree.java

@@ -141,6 +141,7 @@
 import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
+import java.util.regex.Pattern;
 import java.util.stream.IntStream;
 
 /**
@@ -197,6 +198,7 @@ public class ConfigureTree extends JTree implements PropertyChangeListener, Mous
 
   protected JDialog searchDialog;
   protected JTextField searchField;
+  protected JComboBox<String> searchTypeBox;
   protected JCheckBox searchAdvanced;
 
   private final SearchParameters searchParameters;
@@ -1812,8 +1814,11 @@ public Class<? extends Buildable> getChild() {
    */
   private static class SearchParameters {
     public static final String SEARCH_STRING = "searchString"; //$NON-NLS-1$//
+    public static final String SEARCH_TYPE = "searchType"; //$NON-NLS-1$//
+    public static final int TYPE_NORMAL = 0;
+    public static final int TYPE_WORD = 1;
+    public static final int TYPE_REGEX = 2;
     public static final String MATCH_CASE    = "matchCase"; //$NON-NLS-1$//
-    public static final String MATCH_REGEX    = "matchRegex"; //$NON-NLS-1$//
     public static final String MATCH_NAMES   = "matchNames"; //$NON-NLS-1$//
     public static final String MATCH_TYPES   = "matchTypes"; //$NON-NLS-1$//
     public static final String MATCH_ADVANCED     = "matchAdvanced"; //$NON-NLS-1$//
@@ -1827,12 +1832,12 @@ private static class SearchParameters {
     /** Current search string */
     private String searchString;
 
+    /** Current search type */
+    private int searchType;
+
     /** True if case-sensitive */
     private boolean matchCase;
 
-    /** True if matching on a Regular Expression */
-    private boolean matchRegex;
-
     /** True if match configurable names */
     private boolean matchNames;
 
@@ -1867,12 +1872,13 @@ private static class SearchParameters {
      * Constructs a new search parameters object, using the preferences.
      */
     public SearchParameters() {
+
       // Attach to our module preferences if constructed this way. This also marks that we will write them when modified
       prefs = GameModule.getGameModule().getPrefs();
 
       prefs.addOption(null, new StringConfigurer(SearchParameters.SEARCH_STRING, null, ""));
+      prefs.addOption(null, new IntConfigurer(SearchParameters.SEARCH_TYPE, null, SearchParameters.TYPE_NORMAL));
       prefs.addOption(null, new BooleanConfigurer(SearchParameters.MATCH_CASE,   null, false));
-      prefs.addOption(null, new BooleanConfigurer(SearchParameters.MATCH_REGEX,   null, false));
       prefs.addOption(null, new BooleanConfigurer(SearchParameters.MATCH_NAMES,  null, true));
       prefs.addOption(null, new BooleanConfigurer(SearchParameters.MATCH_TYPES,  null, true));
       prefs.addOption(null, new BooleanConfigurer(SearchParameters.MATCH_ADVANCED, null, false));
@@ -1884,8 +1890,8 @@ public SearchParameters() {
       prefs.addOption(null, new BooleanConfigurer(SearchParameters.MATCH_MESSAGES, null, true));
 
       searchString = (String) prefs.getValue(SearchParameters.SEARCH_STRING);
+      searchType = (int) prefs.getValue(SearchParameters.SEARCH_TYPE);
       matchCase    = (Boolean)prefs.getValue(SearchParameters.MATCH_CASE);
-      matchRegex    = (Boolean)prefs.getValue(SearchParameters.MATCH_REGEX);
       matchNames   = (Boolean)prefs.getValue(SearchParameters.MATCH_NAMES);
       matchTypes       = (Boolean)prefs.getValue(SearchParameters.MATCH_TYPES);
       matchAdvanced    = (Boolean)prefs.getValue(SearchParameters.MATCH_ADVANCED);
@@ -1900,10 +1906,10 @@ public SearchParameters() {
     /**
      * Constructs a new search parameters object
      */
-    public SearchParameters(String searchString, boolean matchCase, boolean matchRegex, boolean matchNames, boolean matchTypes, boolean matchAdvanced, boolean matchTraits, boolean matchExpressions, boolean matchProperties, boolean matchKeys, boolean matchMenus, boolean matchMessages) {
+    public SearchParameters(String searchString, int searchType, boolean matchCase, boolean matchNames, boolean matchTypes, boolean matchAdvanced, boolean matchTraits, boolean matchExpressions, boolean matchProperties, boolean matchKeys, boolean matchMenus, boolean matchMessages) {
       this.searchString = searchString;
+      this.searchType = searchType;
       this.matchCase    = matchCase;
-      this.matchRegex    = matchRegex;
       this.matchNames   = matchNames;
       this.matchTypes   = matchTypes;
       this.matchAdvanced    = matchAdvanced;
@@ -1924,12 +1930,12 @@ public void setSearchString(String searchString) {
       writePrefs();
     }
 
-    public boolean isMatchCase() {
-      return matchCase;
+    public int getSearchType() {
+      return searchType;
     }
 
-    public boolean isMatchRegex() {
-      return matchRegex;
+    public boolean isMatchCase() {
+      return matchCase;
     }
 
     public void setMatchCase(boolean matchCase) {
@@ -2022,8 +2028,8 @@ public void setMatchMessages(boolean matchMessages) {
 
     public void setFrom(final SearchParameters searchParameters) {
       searchString = searchParameters.getSearchString();
+      searchType = searchParameters.getSearchType();
       matchCase = searchParameters.isMatchCase();
-      matchRegex = searchParameters.isMatchRegex();
       matchNames = searchParameters.isMatchNames();
       matchTypes = searchParameters.isMatchTypes();
       matchAdvanced    = searchParameters.isMatchAdvanced();
@@ -2039,8 +2045,8 @@ public void setFrom(final SearchParameters searchParameters) {
     public void writePrefs() {
       if (prefs != null) {
         prefs.setValue(SEARCH_STRING, searchString);
+        prefs.setValue(SEARCH_TYPE, searchType);
         prefs.setValue(MATCH_CASE, matchCase);
-        prefs.setValue(MATCH_REGEX, matchRegex);
         prefs.setValue(MATCH_NAMES,       matchNames);
         prefs.setValue(MATCH_TYPES, matchTypes);
         prefs.setValue(MATCH_ADVANCED,    matchAdvanced);
@@ -2063,7 +2069,6 @@ public boolean equals(Object o) {
       }
       final SearchParameters that = (SearchParameters) o;
       return isMatchCase() == that.isMatchCase() &&
-        isMatchRegex() == that.isMatchRegex() &&
         isMatchNames() == that.isMatchNames() &&
         isMatchTypes() == that.isMatchTypes() &&
         isMatchTraits() == that.isMatchTraits() &&
@@ -2073,12 +2078,13 @@ public boolean equals(Object o) {
         isMatchKeys() == that.isMatchKeys() &&
         isMatchMenus() == that.isMatchMenus() &&
         isMatchMessages() == that.isMatchMessages() &&
-        getSearchString().equals(that.getSearchString());
+        getSearchString().equals(that.getSearchString()) &&
+        getSearchType() == that.getSearchType();
     }
 
     @Override
     public int hashCode() {
-      return Objects.hash(getSearchString(), isMatchCase(), isMatchRegex(), isMatchNames(), isMatchTypes(), isMatchAdvanced(),
+      return Objects.hash(getSearchString(), getSearchType(), isMatchCase(), isMatchNames(), isMatchTypes(), isMatchAdvanced(),
         isMatchTraits(), isMatchExpressions(), isMatchProperties(), isMatchKeys(),
         isMatchMenus(), isMatchMessages());
     }
@@ -2090,6 +2096,7 @@ private static class SearchAction extends AbstractAction {
 
     private final ConfigureTree configureTree;
     private final SearchParameters searchParameters;
+    private Pattern regexPattern;
 
     /**
      * Constructs a new {@link SearchAction}
@@ -2123,8 +2130,14 @@ public void actionPerformed(ActionEvent e) {
         configureTree.setSearchField(search);
         search.selectAll();
 
+        // build dropdown menu
+        final JComboBox searchTypeBox = new JComboBox();
+        searchTypeBox.addItem(Resources.getString("Editor.search_optNormal"));
+        searchTypeBox.addItem(Resources.getString("Editor.search_optWord"));
+        searchTypeBox.addItem(Resources.getString("Editor.search_optRegex"));
+        searchTypeBox.setSelectedIndex(searchParameters.getSearchType());
+
         final JCheckBox sensitive = new JCheckBox(Resources.getString("Editor.search_case"), searchParameters.isMatchCase());
-        final JCheckBox regex = new JCheckBox(Resources.getString("Editor.search_regex"), searchParameters.isMatchRegex());
         final JCheckBox advanced  = new JCheckBox(Resources.getString("Editor.search_advanced"), searchParameters.isMatchAdvanced());
 
         final JCheckBox names = new JCheckBox(Resources.getString("Editor.search_names"), searchParameters.isMatchNames());
@@ -2161,7 +2174,7 @@ public void actionPerformed(ActionEvent e) {
         final JButton find = new JButton(Resources.getString("Editor.search_next"));
         find.addActionListener(e12 -> {
           final SearchParameters parametersSetInDialog =
-            new SearchParameters(search.getText(), sensitive.isSelected(), regex.isSelected(), names.isSelected(), types.isSelected(), true, traits.isSelected(), expressions.isSelected(), properties.isSelected(), keys.isSelected(), menus.isSelected(), messages.isSelected());
+            new SearchParameters(search.getText(), searchTypeBox.getSelectedIndex(), sensitive.isSelected(), names.isSelected(), types.isSelected(), true, traits.isSelected(), expressions.isSelected(), properties.isSelected(), keys.isSelected(), menus.isSelected(), messages.isSelected());
 
           final boolean anyChanges = !searchParameters.equals(parametersSetInDialog);
 
@@ -2176,11 +2189,23 @@ public void actionPerformed(ActionEvent e) {
             ConfigureTree.chat(Resources.getString("Editor.search_all_off"));
           }
 
-          if (!searchParameters.getSearchString().isEmpty() && (!searchParameters.isMatchRegex() || isValidRegex(searchParameters.getSearchString()))) {
+          if (!searchParameters.getSearchString().isEmpty()) {
             if (anyChanges) {
-              // Unless we're just continuing to the next match in an existing search, compute & display hit count
-              final int matches = getNumMatches(searchParameters.getSearchString());
-              chat(matches + " " + Resources.getString("Editor.search_count") + noHTML(searchParameters.getSearchString()));
+              boolean regexError = Boolean.FALSE;
+              // Unless we're just continuing to the next match in an existing search, setup.
+              if (searchParameters.getSearchType() != SearchParameters.TYPE_NORMAL) {
+                regexPattern = setupRegexSearch(searchParameters.getSearchString());
+                regexError = regexPattern == null;
+              }
+              else {
+                regexPattern = null;
+              }
+              if (!regexError) {
+                // Compute & display hit count as heading, no indent
+                final int matches = getNumMatches(searchParameters.getSearchString());
+                // FIXME: For some reason leading spaces now being stripped from Resource strings, hence added here
+                chatter.show(matches + " " + (regexPattern == null ? Resources.getString("Editor.search_count") : Resources.getString("Editor.search_countRegex")) + ": " + noHTML(regexPattern == null ? searchParameters.getSearchString() : regexPattern.toString()));
+              }
             }
 
             // Find first match
@@ -2196,7 +2221,8 @@ public void actionPerformed(ActionEvent e) {
               }
             }
             else {
-              chat(Resources.getString("Editor.search_none_found") + noHTML(searchParameters.getSearchString()));
+              // No need to display this on first pass, as we already said zero found.
+              if (!anyChanges) chat(regexPattern == null ? Resources.getString("Editor.search_none_found") + noHTML(searchParameters.getSearchString()) : Resources.getString("Editor.search_noRegex_match") + noHTML(regexPattern.toString()));
             }
           }
         });
@@ -2214,9 +2240,13 @@ public void actionPerformed(ActionEvent e) {
         // top row
         panel.add(search);
 
+        // search type row (dropdown)
+        panel.add(new JLabel((Resources.getString("Editor.searchTypeLabel"))));
+        panel.add(searchTypeBox);
+
+
         // options row
         panel.add(sensitive);
-        panel.add(regex);
         panel.add(advanced);
 
         // Advanced 1
@@ -2327,7 +2357,7 @@ private int getNumMatches(String searchString) {
 
     /**
      * @param st - Search target (usually Decorator or AbstractConfigurable)
-     * @param searchString - our search string
+     * @param searchString - our search string unless superseded by regexPattern
      * @return true if the node matches our searchString based on search configuration ("match" checkboxes)
      */
     private boolean checkSearchTarget(SearchTarget st, String searchString) {
@@ -2427,7 +2457,7 @@ private boolean checkNode(DefaultMutableTreeNode node, String searchString) {
         return false;
       }
 
-      // From here down we are only searching inside of SearchTarget objects (Piece/Prototypes, or searchable AbstractConfigurables)
+      // From here down we are only searching inside SearchTarget objects (Piece/Prototypes, or searchable AbstractConfigurables)
       GamePiece p;
       boolean protoskip;
       if (c instanceof GamePiece) {
@@ -2654,39 +2684,57 @@ else if (c instanceof PrototypeDefinition) {
       }
     }
 
-    private boolean isValidRegex(String searchString) { // avoid exceptions by checking the Regex before use
-      try {
-        return "".matches(searchString) || true;
-      }
-      catch (java.util.regex.PatternSyntaxException e) {
-        chat("Search string is not a valid Regular Expression: " + e.getMessage()); //NON-NLS
-        return false;
-      }
-    }
-
     /**
      * Checks a single string against our search parameters
      * @param target - string to check
-     * @param searchString - our search string
-     * @return true if this is a match based on our "matchCase" & "matchRegex"checkboxes.
+     * @param searchString - our search string - unless superseded by regexPattern
+     * @return true if this is a match based on our search type "matchCase" checkbox.
      */
     private boolean checkString(String target, String searchString) {
-      if (searchParameters.isMatchRegex()) {
+      if (regexPattern == null) {
         if (searchParameters.isMatchCase()) {
-          return target.matches(searchString);
+          return target.contains(searchString);
         }
         else {
-          return target.toLowerCase().matches(searchString.toLowerCase());
+          return target.toLowerCase().contains(searchString.toLowerCase());
         }
       }
       else {
-        if (searchParameters.isMatchCase()) {
-          return target.contains(searchString);
+        // Regular Expression check - match on pattern established in setupRegexPattern()
+        return regexPattern.matcher(target).find();
+      }
+    }
+
+    /**
+     * Initialise a Pattern for subsequent Matcher / Matches
+     * @param searchString - Regex search string
+     * @return Pattern for searches, with an applied default
+     */
+    private Pattern setupRegexSearch(String searchString) {
+
+      final String caseModifier = (searchParameters.isMatchCase() ? "" : "(?i)");
+
+      // regex wrap-around supplied search string
+      if (searchParameters.getSearchType() == SearchParameters.TYPE_WORD) {
+        try {
+          // matching on whatever is provided, starting on a word boundary
+          return Pattern.compile(caseModifier + ".*\\b\\Q" + searchString + "\\E.*?");
         }
-        else {
-          return target.toLowerCase().contains(searchString.toLowerCase());
+        catch (java.util.regex.PatternSyntaxException e) {
+          // something went wrong
+          logger.error("Pattern Syntax Error in default Editor Search: " + noHTML(e.getMessage())); //NON-NLS
+          return null;
         }
       }
+
+      // search string is full regex
+      try {
+        return Pattern.compile(caseModifier + searchString);
+      }
+      catch (java.util.regex.PatternSyntaxException e) {
+        chat("Search string is not a valid Regular Expression: " + noHTML(e.getMessage())); //NON-NLS
+        return null;
+      }
     }
   }
 

vassal-app/src/main/resources/VASSAL/i18n/Editor.properties

@@ -69,9 +69,13 @@ Editor.save=Save
 Editor.save_as=Save as...
 Editor.search=Search...
 Editor.search_string=String to find
+Editor.search_type=Search type
 Editor.search_next=Find next
 Editor.search_case=Exact case
-Editor.search_regex=Regular Expression
+Editor.search_TypeLabel=Search type
+Editor.search_optRegex=Regular Expression
+Editor.search_optNormal=Normal
+Editor.search_optWord=Word boundary
 Editor.search_advanced=Advanced search
 Editor.search_names=Match names
 Editor.search_types=Match [Class names]
@@ -83,7 +87,9 @@ Editor.search_menus=Match UI text
 Editor.search_messages=Match message formats
 Editor.search_all_off=Warning - all field flags unchecked - turning on 'Match Names'
 Editor.search_none_found=Search string not found: 
-Editor.search_count= Matches found for search string: 
+Editor.search_noRegex_match=No match found for Regular Expression: 
+Editor.search_count=matches found for search string
+Editor.search_countRegex=matches found for Regular Expression
 Editor.edit_extension=Edit extension
 Editor.new_extension=New extension
 Editor.cant_cut_ancestor_to_child=Can't paste a cut ancestor to its own child.

vassal-doc/src/main/readme-referencemanual/ReferenceManual/Search.adoc

@@ -9,7 +9,9 @@
 
 VASSAL's Module Editor has a powerful Search facility to find components and pieces in a number of different ways.
 
-The default search is to search for everything, but the Advanced Searh options can be used to limit the type of search performed.
+The default search is to search for everything, but the Advanced Search options can be used to limit the type of search performed.
+
+Note that a search will continue from the last item found and will wrap-around, until you modify the search criteria. This applies even across a restart of editing sessions.
 
 '''''
 
@@ -22,7 +24,7 @@ a|
 Force an Exact case search (i.e. abc is different to ABC).
 
 ===== Regular Expression
-The specified search string is a https://en.wikipedia.org/wiki/Regular_expression[Regular Expression]. In the simplest example, a search for ABC will find matches that equate wholly to "ABC", and lower or mixed case variants (unless _Exact Case_ is checked as well).
+The specified search string is a https://en.wikipedia.org/wiki/Regular_expression[Regular Expression]. If the Search string lacks Regex special characters, a pattern of the form `.\*/b<search string>.*` will be attempted. This default will find matches on words or phrases starting with the search string.
 
 ===== Advanced Search
 Show the advanced search options. All search options are on in a simple search. The advanced options allow you to turn off options to narrow your search.