* Implemented support for 'pattern' attribute, Validator::GetPattern() and SetPattern() & tests.

* Also updated documentation for 'pattern' attribute.
For issue #58.

Author: end2endzone

UserManual.md

@@ -15,6 +15,7 @@ This manual includes a description of the system functionalities and capabilitie
     * [class attribute](#class-attribute)
     * [maxfiles and maxfolders attributes](#maxfiles-and-maxfolders-attributes)
     * [fileextensions attribute](#fileextensions-attribute)
+    * [pattern attribute](#pattern-attribute)
     * [exists attribute](#exists-attribute)
     * [properties attribute](#properties-attribute)
     * [inverse attribute](#inverse-attribute)
@@ -316,6 +317,42 @@ For example, the following set a menu visible only when the user right-click on
 
 
 
+### pattern attribute: ###
+
+The `pattern` attribute validates a menu based on a wildcard pattern matching algorithm. The wildcard pattern can include special characters such as `*` and `?` where
+* `*` Matches any string of zero or more characters.
+* `?` Matches any single character.
+
+If `pattern` attribute is specified, the files selected by the user must match the wildcard pattern for the validation to be successful. To specify multiple patterns, one must separate each pattern value with the `;` character. If multiple patterns are specified, **at least one** pattern must match for the validation to be successful.
+
+If multiple files are selected, the path of each file must match **at least one** pattern for the validation to be successful.
+
+If `pattern` attribute is not specified, then the validation is successful.
+
+For example, the following set a menu visible only when the user right-click on JPEG image files which filenames start by `IMG``:
+```xml
+<visibility pattern="*\IMG*.jpg" />
+```
+
+The following table show useful pattern examples:
+
+| Pattern                                                       | Meaning                                                                                       |
+|---------------------------------------------------------------|-----------------------------------------------------------------------------------------------|
+| \\e\*.???                                                     | Matches filenames beginning with the letter `e`.                                              |
+| \*e.???                                                       | Matches filename ending with the letter `e`.                                                  |
+| \*vacations\*                                                 | Matches files that have the word `vacations` in their path.                                   |
+| \*2019\*                                                      | Matches files that have the year 2019 in the filename or directory path.                      |
+| \*\\DCIM\\\*                                                  | Matches the files located in a Digital Camera Images directory.                               |
+| C:\Program Files\\\*;<br>C:\Program Files (x86)\\\*           | Matches files that are located in `C:\Program Files` or `C:\Program Files (x86)` directories. |
+| ${env.USERPROFILE}\\Downloads;<br>${env.USERPROFILE}\\Desktop | Matches files that are located in the user's `Downloads` or `Desktop` directories.            |
+| D:\\\*                                                        | Matches files located on the D: drive.                                                        |
+| \*\\IMG_????.JPG;<br>\*\\DSC_????.JPG                         | Matches Canon or Nikon image files.                                                           |
+
+**Note:**
+The `pattern` attribute should not be used for matching files by file extension. The `fileextensions` attribute should be used instead.
+
+
+
 ### exists attribute: ###
 
 The `exists` attribute validates a menu if the specified file or directory exists.
@@ -364,6 +401,7 @@ The meaning of each inversed attribute in explained in the following table:
 | maxfiles       | Defines a minimum number of selected files. Validates a menu if **more than** _x_ files are selected.<br>If 'maxfiles` is set to 5, _more than_ 5 files must be selected for the validation to be successful.                                |
 | maxfolders     | Defines a minimum number of selected folder. Validates a menu if **more than** _x_ folders are selected.<br>If 'maxfolders` is set to 3, _more than_ 3 directories must be selected for the validation to be successful.                     |
 | fileextensions | Validates a menu if the given file's extension **does not** match the file extension selected by the user.<br>If multiple file extensions are specified, **no extension** must match the selected files for the validation to be successful. |
+| pattern        | Validates a menu if the selected file or directory **does not** match the wildcard pattern matching algorithm.<br>If multiple patterns are specified, **no pattern** must match the selected files for the validation to be successful.      |
 | exists         | Validates a menu if the selected file or directory **does not** exists.<br>If multiple files/directories are specified, **all values** must _not exists_ on the system for the validation to be successful.                                  |
 | properties     | Validates a menu if the specified property is **empty** or **not defined**.<br>If multiple properties are specified, **all properties** must be _empty_ or _not defined_ for the validation to be successful.                                |
 

include/shellanything/Validator.h

@@ -104,6 +104,16 @@ namespace shellanything
     /// </summary>
     void SetClass(const std::string & iClass);
 
+    /// <summary>
+    /// Getter for the 'pattern' parameter.
+    /// </summary>
+    const std::string & GetPattern() const;
+
+    /// <summary>
+    /// Setter for the 'pattern' parameter.
+    /// </summary>
+    void SetPattern(const std::string & iPattern);
+
     /// <summary>
     /// Getter for the 'inserve' parameter.
     /// </summary>
@@ -141,6 +151,7 @@ namespace shellanything
     bool ValidateExists(const Context & context, const std::string & file_exists, bool inversed) const;
     bool ValidateClass(const Context & context, const std::string & class_, bool inversed) const;
     bool ValidateClassSingle(const Context & context, const std::string & class_, bool inversed) const;
+    bool ValidatePattern(const Context & context, const std::string & pattern, bool inversed) const;
 
   private:
     int mMaxFiles;
@@ -149,6 +160,7 @@ namespace shellanything
     std::string mFileExtensions;
     std::string mFileExists;
     std::string mClass;
+    std::string mPattern;
     std::string mInverse;
   };
 

src/ObjectFactory.cpp

@@ -169,6 +169,16 @@ namespace shellanything
       }
     }
 
+    //parse pattern
+    std::string pattern;
+    if (ParseAttribute(element, "pattern", true, true, pattern, error))
+    {
+      if (!pattern.empty())
+      {
+        result.SetPattern(pattern);
+      }
+    }
+
     //parse maxfiles
     int maxfiles = -1;
     if (ParseAttribute(element, "maxfiles", true, true, maxfiles, error))

src/Validator.cpp

@@ -27,6 +27,7 @@
 #include "shellanything/Validator.h"
 #include "PropertyManager.h"
 #include "DriveClass.h"
+#include "Wildcard.h"
 #include "rapidassist/strings.h"
 #include "rapidassist/filesystem_utf8.h"
 
@@ -81,6 +82,7 @@ namespace shellanything
       mFileExtensions = validator.mFileExtensions ;
       mFileExists     = validator.mFileExists     ;
       mClass          = validator.mClass          ;
+      mPattern        = validator.mPattern        ;
       mInverse        = validator.mInverse        ;
     }
     return (*this);
@@ -146,6 +148,16 @@ namespace shellanything
     mClass = iClass;
   }
 
+  const std::string & Validator::GetPattern() const
+  {
+    return mPattern;
+  }
+
+  void Validator::SetPattern(const std::string & iPattern)
+  {
+    mPattern = iPattern;
+  }
+
   const std::string & Validator::GetInserve() const
   {
     return mInverse;
@@ -269,6 +281,16 @@ namespace shellanything
         return false;
     }
 
+    //validate pattern
+    const std::string pattern = pmgr.Expand(mPattern);
+    if (!pattern.empty())
+    {
+      bool inversed = IsInversed("pattern");
+      bool valid = ValidatePattern(iContext, pattern, inversed);
+      if (!valid)
+        return false;
+    }
+
     return true;
   }
 
@@ -507,4 +529,45 @@ namespace shellanything
     return true;
   }
 
+  bool WildcardMatch(const ra::strings::StringVector & patterns, const char * value)
+  {
+    for(size_t j=0; j<patterns.size(); j++)
+    {
+      const std::string & pattern = patterns[j];
+      bool match = WildcardMatch(pattern.c_str(), value);
+      if (match)
+        return true;
+    }
+    return false;
+  }
+
+  bool Validator::ValidatePattern(const Context & context, const std::string & pattern, bool inversed) const
+  {
+    if (pattern.empty())
+      return true;
+
+    PropertyManager & pmgr = PropertyManager::GetInstance();
+
+    //split
+    ra::strings::StringVector patterns = ra::strings::Split(pattern, ";");
+    Uppercase(patterns);
+
+    //for each file selected
+    const Context::ElementList & elements = context.GetElements();
+    for(size_t i=0; i<elements.size(); i++) 
+    {
+      const std::string & element = elements[i];
+      std::string element_uppercase = ra::strings::Uppercase(element);
+
+      //each element must match one of the patterns
+      bool match = WildcardMatch(patterns, element_uppercase.c_str());
+      if (!inversed && !match)
+        return false; //current file does not match any patterns
+      if (inversed && match)
+        return false; //current element is not accepted
+    }
+
+    return true;
+  }
+
 } //namespace shellanything

test/TestObjectFactory.cpp

@@ -150,9 +150,9 @@ namespace shellanything { namespace test
     Configuration::ConfigurationPtrList configs = cmgr.GetConfigurations();
     ASSERT_EQ( 1, configs.size() );
 
-    //ASSERT a 8 menus are available
+    //ASSERT all menus are available
     Menu::MenuPtrList menus = cmgr.GetConfigurations()[0]->GetMenus();
-    ASSERT_EQ( 9, menus.size() );
+    ASSERT_EQ( 10, menus.size() );
 
     //assert <visibility> tag properly parsed
     static const std::string expected_property = "bar";
@@ -163,6 +163,7 @@ namespace shellanything { namespace test
     static const std::string expected_inverse_many = "maxfiles;maxfolders";
     static const std::string expected_inverse_unknown = "foo";
     static const std::string expected_class = "file";
+    static const std::string expected_pattern = "*IMG_*";
 
     ASSERT_EQ( expected_property,         menus[0]->GetVisibility().GetProperties() );
     ASSERT_EQ( 5,                         menus[1]->GetVisibility().GetMaxFiles() );
@@ -174,6 +175,7 @@ namespace shellanything { namespace test
     ASSERT_EQ( expected_inverse_many,     menus[6]->GetVisibility().GetInserve() );
     ASSERT_EQ( expected_inverse_unknown,  menus[7]->GetVisibility().GetInserve() );
     ASSERT_EQ( expected_class,            menus[8]->GetVisibility().GetClass() );
+    ASSERT_EQ( expected_pattern,          menus[9]->GetVisibility().GetPattern() );
 
     //cleanup
     ASSERT_TRUE( ra::filesystem::DeleteFile(template_target_path.c_str()) ) << "Failed deleting file '" << template_target_path << "'.";

test/TestValidator.cpp

@@ -362,6 +362,50 @@ namespace shellanything { namespace test
 
   }
   //--------------------------------------------------------------------------------------------------
+  TEST_F(TestValidator, testPattern)
+  {
+    Context c;
+#ifdef _WIN32
+    {
+      Context::ElementList elements;
+      elements.push_back("C:\\Windows\\System32\\kernel32.dll");
+      elements.push_back("C:\\Windows\\System32\\cmd.exe"     );
+      elements.push_back("C:\\Windows\\System32\\notepad.exe" );
+      elements.push_back("C:\\Windows\\System32\\services.msc");
+      c.SetElements(elements);
+    }
+#else
+    //TODO: complete with known path to files
+#endif
+
+    Validator v;
+
+    //assert default
+    ASSERT_TRUE( v.Validate(c) );
+
+    //assert failure when no pattern is matching
+    v.SetPattern("foo");
+    ASSERT_FALSE( v.Validate(c) );
+
+    //assert failure when patterns is matching only a single file
+    v.SetPattern("*cmd.exe");
+    ASSERT_FALSE( v.Validate(c) );
+
+    //assert success when patterns are matching all files
+    v.SetPattern("*.dll;*.exe;*.msc");
+    ASSERT_TRUE( v.Validate(c) );
+    v.SetPattern("*.exe;*.dll;*.msc"); //random order
+    ASSERT_TRUE( v.Validate(c) );
+
+    //assert success when more than required patterns are provided
+    v.SetPattern("*e*;*.dll;*.exe;*.msc;*a*;");
+    ASSERT_TRUE( v.Validate(c) );
+
+    //assert failure when multiple files are selected and a single pattern is missing
+    v.SetPattern("*.dll;*.exe"); //missing msc file extension
+    ASSERT_FALSE( v.Validate(c) );
+  }
+  //--------------------------------------------------------------------------------------------------
   TEST_F(TestValidator, testIsInversed)
   {
     Validator v;
@@ -578,7 +622,7 @@ namespace shellanything { namespace test
     v.SetFileExtensions("dll");
     ASSERT_FALSE( v.Validate(c) );
 
-    //assert failure when all properties are defined
+    //assert failure when all file extensions are defined
     v.SetFileExtensions("dll;exe;msc");
     ASSERT_FALSE( v.Validate(c) );
     v.SetFileExtensions("exe;dll;msc"); //random order
@@ -641,6 +685,53 @@ namespace shellanything { namespace test
     ASSERT_FALSE( v.Validate(c) );
   }
   //--------------------------------------------------------------------------------------------------
+  TEST_F(TestValidator, testPatternInversed)
+  {
+    Context c;
+#ifdef _WIN32
+    {
+      Context::ElementList elements;
+      elements.push_back("C:\\Windows\\System32\\kernel32.dll");
+      elements.push_back("C:\\Windows\\System32\\cmd.exe"     );
+      elements.push_back("C:\\Windows\\System32\\notepad.exe" );
+      elements.push_back("C:\\Windows\\System32\\services.msc");
+      c.SetElements(elements);
+    }
+#else
+    //TODO: complete with known path to files
+#endif
+
+    Validator v;
+    v.SetInserve("pattern");
+
+    //assert default
+    ASSERT_TRUE( v.Validate(c) );
+
+    //assert success when no pattern is matching
+    v.SetPattern("foo");
+    ASSERT_TRUE( v.Validate(c) );
+
+    //assert failure when a pattern is matching a single file
+    v.SetPattern("*.dll");
+    ASSERT_FALSE( v.Validate(c) );
+
+    //assert failure when pattern is matching all files
+    v.SetPattern("*.dll;*.exe;*.msc");
+    ASSERT_FALSE( v.Validate(c) );
+    v.SetPattern("*.exe;*.dll;*.msc"); //random order
+    ASSERT_FALSE( v.Validate(c) );
+
+    //assert failure when more than required patterns are provided
+    v.SetPattern("*e*;*.dll;*.exe;*.msc;*a*;");
+    ASSERT_FALSE( v.Validate(c) );
+
+    // If multiple patterns are specified, no pattern must match for the validation to be successful.
+    v.SetPattern("*.foo;*.bar;*.baz;");
+    ASSERT_TRUE( v.Validate(c) );
+    v.SetPattern("*.foo;*.exe;*.bar;*.baz;");
+    ASSERT_FALSE( v.Validate(c) );
+  }
+  //--------------------------------------------------------------------------------------------------
   TEST_F(TestValidator, testInversedAll)
   {
     Validator v;

test/test_files/TestObjectFactory.testParseValidator.xml

@@ -73,5 +73,13 @@
       </actions>
     </menu>
 
+    <menu name="menu09">
+      <!-- pattern attribute is set -->
+      <visibility pattern="*IMG_*" />
+      <actions>
+        <property name="baz" value="true" />
+      </actions>
+    </menu>
+
   </shell>
 </root>