Merge pull request #51 from molsonkiko/glob_syntax

add support for glob syntax, address issue 50

Author: young-developer

NppNavigateTo/Forms/AboutForm.cs

@@ -8,6 +8,7 @@
 using System.Reflection;
 using System.Text;
 using System.Windows.Forms;
+using NppPluginNET;
 
 namespace NavigateTo.Plugin.Namespace
 {
@@ -16,7 +17,7 @@ public partial class AboutForm : Form
         public AboutForm()
         {
             InitializeComponent();
-            Title.Text = $"NavigateTo v{AssemblyVersionString()}";
+            Title.Text = $"NavigateTo v{MiscUtils.AssemblyVersionString()}";
             FormStyle.ApplyStyle(this, true, Main.notepad.IsDarkModeEnabled());
         }
 
@@ -44,14 +45,6 @@ private void GitHubLink_LinkClicked(object sender, LinkLabelLinkClickedEventArgs
             }
         }
 
-        public static string AssemblyVersionString()
-        {
-            string version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
-            while (version.EndsWith(".0"))
-                version = version.Substring(0, version.Length - 2);
-            return version;
-        }
-
         /// <summary>
         /// Escape key exits the form.
         /// </summary>

NppNavigateTo/Forms/FrmNavigateTo.cs

@@ -0,0 +1,271 @@
+using Kbg.NppPluginNET.PluginInfrastructure;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Windows.Forms;
+
+namespace NavigateTo.Plugin.Namespace
+{
+    public enum Ternary
+    {
+        FALSE,
+        TRUE,
+        UNDECIDED,
+    }
+
+    public class GlobFunction
+    {
+        public Func<string, bool> Matcher { get; }
+        public bool Or { get; }
+        public bool Negated { get; }
+
+        public GlobFunction(Func<string, bool> matcher, bool or, bool negated)
+        {
+            this.Matcher = matcher;
+            this.Or = or;
+            this.Negated = negated;
+        }
+
+        public Ternary IsMatch(string inp, Ternary previousResult)
+        {
+            if (Or && (previousResult == Ternary.TRUE))
+                return Ternary.TRUE;
+            if (!Or && (previousResult == Ternary.FALSE))
+                return Ternary.FALSE;
+            bool result = Matcher(inp);
+            return (result ^ Negated) ? Ternary.TRUE : Ternary.FALSE;
+        }
+    }
+
+    /// <summary>
+    /// parser that parses glob syntax in space-separated globs<br></br>
+    /// 1. Default behavior is to match ALL space-separated globs
+    ///     (e.g. "foo bar txt" matches "foobar.txt" and "bartxt.foo")<br></br>
+    /// 2. Also use glob syntax:<br></br>
+    ///     * "*" matches any number (incl. zero) of characters except "\\"<br></br>
+    ///     * "**" matches any number (incl. zero) of characters including "\\"<br></br>
+    ///     * "[chars]" matches all characters inside the square brackets (same as in Perl-style regex, also includes character classes like [a-z], [0-9]). Note: can match ' ', which is normally a glob separator<br></br>
+    ///     * "[!chars]" matches NONE of the characters inside the square brackets (and also doesn't match "\\") (same as Perl-style "[^chars]")<br></br>
+    ///     * "foo.{abc,def,hij}" matches "foo.abc", "foo.def", or "foo.hij". Essentially "{x,y,z}" is equivalent to "(?:x|y|z)" in Perl-style regex<br></br>
+    ///     * "?" matches any one character except "\\"<br></br>
+    /// 3. "foo | bar" matches foo OR bar ("|" implements logical OR)<br></br>
+    /// 4. "!foo" matches anything that DOES NOT CONTAIN "foo"<br></br>
+    /// 5. "foo | &lt;baz bar&gt;" matches foo OR (bar AND baz) (that is, "&lt;" and "&gt;" act as grouping parentheses)
+    /// </summary>
+    public class Glob
+    {
+        public int ii;
+        public string ErrorMsg;
+        public int ErrorPos;
+        public List<string> globs;
+
+        public Glob()
+        {
+            globs = new List<string>();
+            Reset();
+        }
+
+        public void Reset()
+        {
+            globs.Clear();
+            ErrorMsg = null;
+            ErrorPos = -1;
+            ii = 0;
+        }
+
+        public char Peek(string inp)
+        {
+            return (ii < inp.Length - 1)
+                ? inp[ii + 1]
+                : '\x00';
+        }
+
+        public Regex Glob2Regex(string inp)
+        {
+            var sb = new StringBuilder();
+            int start = ii;
+            bool is_char_class = false;
+            bool uses_metacharacters = false;
+            bool is_alternation = false;
+            while (ii < inp.Length)
+            {
+                char c = inp[ii];
+                char next_c;
+                switch (c)
+                {
+                case '/': sb.Append("\\\\"); break;
+                case '\\':
+                    next_c = Peek(inp);
+                    if (next_c == 'x' || next_c == 'u' // \xNN, \uNNNN unicode escapes
+                        || (next_c == ']' && is_char_class))
+                        sb.Append('\\'); 
+                    else
+                        sb.Append("\\\\");
+                    break;
+                case '*':
+                    if (is_char_class)
+                    {
+                        sb.Append("\\*"); // "[*]" matches literal * character
+                        break;
+                    }
+                    else if (sb.Length == 0)
+                        break; // since globs are only anchored at the end,
+                               // leading * in globs should not influence the matching behavior.
+                               // For example, the globs "*foo.txt" and "foo.txt" should match the same things.
+                    uses_metacharacters = true;
+                    next_c = Peek(inp);
+                    if (next_c == '*')
+                    {
+                        ii++;
+                        // "**" means recursive search; ignores path delimiters
+                        sb.Append(".*");
+                    }
+                    else
+                    {
+                        // "*" means anything but a path delimiter
+                        sb.Append(@"[^\\]*");
+                    }
+                    break;
+                case '[':
+                    uses_metacharacters = true;
+                    sb.Append('[');
+                    next_c = Peek(inp);
+                    if (!is_char_class && next_c == '!')
+                    {
+                        sb.Append("^\\\\"); // [! begins a negated char class, but also need to exclude path sep
+                        ii++;
+                    }
+                    is_char_class = true;
+                    break;
+                case ']':
+                    is_char_class = false;
+                    sb.Append(']');
+                    break; // TODO: consider allowing nested [] inside char class
+                case '{':
+                    if (is_char_class)
+                        sb.Append("\\{");
+                    else
+                    {
+                        uses_metacharacters = true;
+                        is_alternation = true; // e.g. *.{cpp,h,c} matches *.cpp or *.h or *.c
+                        sb.Append("(?:");
+                    }
+                    break;
+                case '}':
+                    if (is_char_class)
+                        sb.Append("\\}");
+                    else
+                    {
+                        sb.Append(")");
+                        is_alternation = false;
+                    }
+                    break;
+                case ',':
+                    if (is_alternation)
+                        sb.Append('|'); // e.g. *.{cpp,h,c} matches *.cpp or *.h or *.c
+                    else
+                        sb.Append(',');
+                    break;
+                case '.': case '$': case '(': case ')': case '^':
+                    // these chars have no special meaning in glob syntax, but they're regex metacharacters
+                    sb.Append('\\');
+                    sb.Append(c);
+                    break;
+                case '?':
+                    if (is_char_class)
+                        sb.Append('?');
+                    else
+                    {
+                        uses_metacharacters = true;
+                        sb.Append(@"[^\\]"); // '?' is any single char
+                    }
+                    break;
+                case '|': case '<': case '>': case ';': case '\t':
+                    goto endOfLoop; // these characters are never allowed in Windows paths
+                case ' ': case '!':
+                    if (is_char_class)
+                        sb.Append(c);
+                    else
+                        goto endOfLoop; // allow ' ' and '!' inside char classes, but otherwise these are special chars in NavigateTo
+                    break;
+                default:
+                    sb.Append(c);
+                    break;
+                }
+                ii++;
+            }
+            endOfLoop:
+            if (uses_metacharacters) // anything without "*" or "?" or "[]" or 
+                sb.Append('$'); // globs are anchored at the end; that is "*foo" does not match "foo/bar.txt" but "*foo.tx?" does
+            string pat = sb.ToString();
+            try
+            {
+                var regex = new Regex(pat, RegexOptions.IgnoreCase | RegexOptions.Compiled);
+                globs.Add(pat);
+                return regex;
+            }
+            catch (Exception ex)
+            {
+                ErrorMsg = ex.Message;
+                ErrorPos = start;
+                return null;
+            }
+        }
+
+        public Func<string, bool> Parse(string inp, bool fromBeginning = true)
+        {
+            if (fromBeginning)
+                Reset();
+            bool or = false;
+            bool negated = false;
+            var globFuncs = new List<GlobFunction>();
+            while (ii < inp.Length)
+            {
+                char c = inp[ii];
+                if (c == ' ' || c == '\t' || c == ';') { }
+                else if (c == '|')
+                    or = true;
+                else if (c == '!')
+                    negated = !negated;
+                else if (c == '<')
+                {
+                    ii++;
+                    var subFunc = Parse(inp, false);
+                    globFuncs.Add(new GlobFunction(subFunc, or, negated));
+                    negated = false;
+                    or = false;
+                }
+                else if (c == '>')
+                    break;
+                else
+                {
+                    var globRegex = Glob2Regex(inp);
+                    if (globRegex == null)
+                        continue; // ignore errors, try to parse everything else
+                    globFuncs.Add(new GlobFunction(globRegex.IsMatch, or, negated));
+                    ii--;
+                    negated = false;
+                    or = false;
+                }
+                ii++;
+            }
+            ii++;
+            if (globFuncs.All(gf => !gf.Or))
+                // return a more efficient function that short-circuits
+                // if none of the GlobFunctions use logical or
+                return (string x) => globFuncs.All(gf => gf.Matcher(x) ^ gf.Negated);
+            bool finalFunc(string x)
+            {
+                Ternary result = Ternary.UNDECIDED;
+                foreach (GlobFunction globFunc in globFuncs)
+                {
+                    result = globFunc.IsMatch(x, result);
+                }
+                return result != Ternary.FALSE;
+            }
+            return finalFunc;
+        }
+    }
+}

NppNavigateTo/Glob.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Reflection;
+using System.Text;
+using System.Windows.Forms;
+using Kbg.NppPluginNET.PluginInfrastructure;
+
+namespace NppPluginNET
+{
+    /// <summary>
+    /// contains connectors to Scintilla (editor) and Notepad++ (notepad)
+    /// and miscellaneous other helper functions
+    /// </summary>
+    public class MiscUtils
+    {
+        /// <summary>
+        /// connector to Scintilla
+        /// </summary>
+        public static IScintillaGateway editor = NavigateTo.Plugin.Namespace.Main.editor;
+        /// <summary>
+        /// connector to Notepad++
+        /// </summary>
+        public static INotepadPPGateway notepad = NavigateTo.Plugin.Namespace.Main.notepad;
+
+        /// <summary>
+        /// append text to current doc, then append newline and move cursor
+        /// </summary>
+        /// <param name="inp"></param>
+        public static void AddLine(string inp)
+        {
+            editor.AppendText(Encoding.UTF8.GetByteCount(inp), inp);
+            editor.AppendText(Environment.NewLine.Length, Environment.NewLine);
+        }
+
+        /// <summary>
+        /// input is one of 'p', 'd', 'f'<br></br>
+        /// if 'p', get full path to current file (default)<br></br>
+        /// if 'd', get directory of current file<br></br>
+        /// if 'f', get filename of current file
+        /// </summary>
+        /// <param name="which"></param>
+        /// <returns></returns>
+        public static string GetCurrentPath(char which = 'p')
+        {
+            NppMsg msg = NppMsg.NPPM_GETFULLCURRENTPATH;
+            switch (which)
+            {
+            case 'p': break;
+            case 'd': msg = NppMsg.NPPM_GETCURRENTDIRECTORY; break;
+            case 'f': msg = NppMsg.NPPM_GETFILENAME; break;
+            default: throw new ArgumentException("GetCurrentPath argument must be one of 'p', 'd', 'f'");
+            }
+
+            StringBuilder path = new StringBuilder(Win32.MAX_PATH);
+            Win32.SendMessage(PluginBase.nppData._nppHandle, (uint)msg, 0, path);
+
+            return path.ToString();
+        }
+
+        /// <summary>
+        /// Trying to copy an empty string or null to the clipboard raises an error.<br></br>
+        /// This shows a message box if the user tries to do that.
+        /// </summary>
+        /// <param name="text"></param>
+        public static void TryCopyToClipboard(string text)
+        {
+            if (text == null || text.Length == 0)
+            {
+                MessageBox.Show("Couldn't find anything to copy to the clipboard",
+                    "Nothing to copy to clipboard",
+                    MessageBoxButtons.OK,
+                    MessageBoxIcon.Warning
+                );
+                return;
+            }
+            Clipboard.SetText(text);
+        }
+
+        public static string AssemblyVersionString()
+        {
+            string version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
+            while (version.EndsWith(".0"))
+                version = version.Substring(0, version.Length - 2);
+            return version;
+        }
+    }
+}