Awesome

Features

• Interactive RegExp Testing: Hypersonic provides an interactive testing environment right within NeoVim. You can easily write your RegExp patterns and instantly see the matches highlighted in real-time.

• Pattern Explanation: Understanding complex RegExp patterns can be challenging. Hypersonic comes with an integrated pattern explanation feature that provides detailed explanations for your RegExp patterns, helping you grasp their meaning and behavior.

Currently accessible

• Simple RegExp explanation
• Simple error handling techniques
• CommandLine live explanation
• Language support for LUA, PHP

Known issues

• Does not work in v0.8.3 (only tested one)
• Nested groups do not display correctly
• Advanced regex is not working (e.g. (?:))
  • named capturing group ((?:<name>))
  • non-capturing group ((?:))
  • look-around ((?=), (?!), (?<=), (?<!))

Usage

1. selecting
   • select RegExp then enter command :Hypersonic
   • <details> <summary> preview </summary> <img src='https://github.com/user-attachments/assets/f2179401-d353-4fb1-98f0-6ea5b3437a13'>
   </details>
2. command
   • enter command: :Hypersonic your-regex
   • <details> <summary> preview </summary> <img src='https://github.com/user-attachments/assets/215b3555-8fe3-4750-9137-8e11215b2dd1'>
   </details>
3. command-line search
   • in cmd search /your-regex or ?your-regex
   • <details> <summary> preview </summary> <img src='https://github.com/user-attachments/assets/06e14129-9f10-4b58-b6a7-7661b75f7265'>
   </details>

Installation

Plug 'tomiis4/Hypersonic.nvim'

use 'tomiis4/Hypersonic.nvim'

{
    'tomiis4/Hypersonic.nvim',
    event = "CmdlineEnter",
    cmd = "Hypersonic",
    config = function()
        require('hypersonic').setup({
            -- config
        })
    end
},

Setup

require('hypersonic').setup()

require('hypersonic').setup({
    ---@type 'none'|'single'|'double'|'rounded'|'solid'|'shadow'|table
    border = 'rounded',
    ---@type number 0-100
    winblend = 0,
    ---@type boolean
    add_padding = true,
    ---@type string
    hl_group = 'Keyword',
    ---@type string
    wrapping = '"',
    ---@type boolean
    enable_cmdline = true
})

File order

|   LICENSE
|   README.md
|
+---lua
|   \---hypersonic
|           config.lua
|           explain.lua
|           init.lua
|           merge.lua
|           split.lua
|           tables.lua
|           utils.lua
|
+---plugin
|       hypersonic.lua
|
\---test
        testing_file.txt
        testing_file.lua

How does it work?

Process

• Take regex from current line.
• Spit to specified format.
• Explain that regex.
• Merge it for better readability.
• Return result in floating window.

Split

gr[ae]y

{
    {
        type = "character",
        value = "g"
    },
    {
        type = "character",
        value = "r"
    },
    {
        type = "class",
        value = "ae"
    },
    {
        type = "character",
        value = "y"
    }
}

local meta_table = {
    ['n'] = 'Newline',
    ['r'] = 'Carriage return',
    ['t'] = 'Tab',
    ['s'] = 'Any whitespace character',
    ['S'] = 'Any non-whitespace character',
    ['d'] = 'Any digit',
    -- more in tables.lua
}

{
    type = 'character'|'escaped'|'class'|'group'|'quantifier',
    value = '',
    children = Node|{},
    quantifiers = ''
}

• create new table main={} (type: Node[])
• loop for each char
  • \
    • add future char to main
    • skip that char
  • [
    • get closing ]
    • add content between [] to main
    • skip to closing ]
  • (
    • get closing )
    • add split content between () to children
    • skip to closing )
  • ?|+|*
    • add char to previous Node.quantifiers
  • other
    • create Node with that char

Explain

{
    {
        type = "character",
        value = "g"
    },
    {
        type = "character",
        value = "r"
    },
    {
        type = "class",
        value = "ae"
    },
    {
        type = "character",
        value = "y"
    }
}

{
    {
        explanation = "Match g",
        value = "g"
    },
    {
        explanation = "Match r",
        value = "r"
    },
    {
        children = { "a", "e" },
        explanation = "Match either",
        value = "[ae]"
    },
    {
        explanation = "Match y",
        value = "y"
    }
}

• create new table main={} (type: Explained[])
• loop for each Node
  • type == escaped | character
    • explain character
    • check if is in any table
      • return that value
  • type == class
    • call explain_class
  • type == group
    • call explain

Merge

{
    {
        explanation = "Match g",
        value = "g"
    },
    {
        explanation = "Match r",
        value = "r"
    },
    {
        children = { "a", "e" },
        explanation = "Match either",
        value = "[ae]"
    },
    {
        explanation = "Match y",
        value = "y"
    }
}

{ 
    {
        explanation = "Match gr",
        value = "gr"
    }, 
    {
        explanation = "Match either",
        children = { "a or e" },
        value = "[ae]"
    }, 
    {
        explanation = "Match y",
        value = "y"
    }
}

+-gr[ae]y------------------------------+
| "gr":   Match gr                     |
| "[ae]": Match either                 |
|    1) a or e                         |
| "y":    Match y                      |
+--------------------------------------+

Contributors