Topics

Language breakdown

No language data available.

▸ Files click to expand

README

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

selecting

- select RegExp then enter command :Hypersonic -

preview

command

- enter command: :Hypersonic your-regex -

preview

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}

🔗 More in this category