Hypersonic - NeoVim Plugin for Regex Writing and Testing

A powerful NeoVim plugin created to increase your regular expression (RegExp) writing and testing experience. Whether you're a newbie or professional developer, Hypersonic is here to make your life easier and boost your productivity.

---

Colorscheme: Rose-Pine; Font: JetBrainsMono NF

---

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
   • preview

     
2. command
   • enter command: :Hypersonic your-regex
   • preview

     
3. command-line search
   • in cmd search /your-regex or ?your-regex
   • preview

     

Installation

Using vim-plug

Plug 'tomiis4/Hypersonic.nvim'

Using packer

use 'tomiis4/Hypersonic.nvim'

Using lazy

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

Setup

require('hypersonic').setup()

Default configuration

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

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

input

gr[ae]y

output

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

meta characters table

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
}

Node

{
    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

input

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

output

{
    {
        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

input

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

output

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

NeoVim output

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

Contributors

tomiis4 founder

NormTurtle command-line preview idea

leekool spelling specialist