Lib.rs

1. 这个工具做什么？

grex 既是库又是命令行工具，旨在简化创建正则表达式这一通常复杂且繁琐的任务。它通过从用户提供的测试案例中自动生成单个正则表达式来实现这一点。生成的表达式将保证匹配它所生成的测试案例。

这个项目最初是 Devon Govett 编写的 JavaScript 工具 regexgen 的 Rust 版本。尽管可以添加很多其他有用的功能，但它的开发似乎已经停止了几年。现在计划将这些新功能添加到 grex 中，因为 Rust 在命令行工具方面表现出色。grex 提供了所有 regexgen 提供的功能，还有更多。

这个项目的理念是默认生成最具体的正则表达式，它只与给定的输入完全匹配，而不匹配其他任何内容。通过使用命令行标志（在 CLI 工具中）或预处理方法（在库中），可以创建更通用的表达式。

生成的表达式是兼容 Perl 的正则表达式，也兼容 Rust 的 regex crate 中的正则表达式解析器。迄今为止，尚未测试其他正则表达式解析器或相应编程语言的库，但它们应该也与大多数兼容。

2. 我还需要学习编写正则表达式吗？

当然需要！ 使用标准设置，grex 生成的正则表达式将保证只匹配输入的测试案例，而不匹配其他任何内容。这已经通过 属性测试 验证。然而，如果启用了转换为缩写字符类（如 \w）的转换，生成的正则表达式将匹配更广泛的测试案例。了解这种转换的后果对于找到适合您业务领域的正确正则表达式至关重要。

grex 使用一种算法，尝试为给定的测试用例找到最短的可能的正则表达式。然而，生成的表达式通常仍然比所需的更长或更复杂。在这种情况下，只有通过手动操作才能创建更紧凑或更优雅的正则表达式。此外，每个正则表达式引擎都有不同的内置优化。 grex 对这些一无所知，因此无法针对特定引擎优化其正则表达式。

因此，请学习如何编写正则表达式！ 目前 grex 的最佳用途是找到一个初始正确的正则表达式，如果可能进行进一步优化，则应手动检查。

3. 当前功能

• 字面量
• 字符类
• 检测常见的前缀和后缀
• 检测重复的子字符串，并将其转换为 {min,max} 量词表示法
• 使用 | 操作符进行选择
• 使用 ? 量词进行可选性
• 转义非 ASCII 字符，可选地将天顶字码点转换为代理对
• 区分大小写或大小写不敏感匹配
• 捕获组或非捕获组
• 可选锚点 ^ 和 $
• 完全符合 Unicode 标准版本 15.0
• 完全兼容 regex 包 1.9.0+
• 正确处理由多个 Unicode 符号组成的图形符号
• 从命令行或文件读取输入字符串
• 在可选的详细模式下，通过缩进来生成更易读的表达式
• 在支持的终端中，可选语法高亮以获得更好的输出

4. 如何安装？

4.1 命令行工具

您可以从上面下载适用于您平台的独立可执行文件并将其放置在您选择的位置。或者，在软件包管理器中提供了预编译的 64 位二进制文件，包括 Scoop（Windows），Homebrew（macOS 和 Linux），MacPorts（macOS），以及 Huber（macOS、Linux 和 Windows）。 Raúl Piracés 贡献了一个 Chocolatey Windows 包。

grex 还托管在 crates.io，官方 Rust 包注册处。如果您是 Rust 开发者并且已经安装了 Rust 工具链，您可以使用 Rust 包管理器 cargo 从源代码编译并安装。因此，您的安装选项总结如下

( brew | cargo | choco | huber | port | scoop ) install grex

4.2 库

要使用 grex 作为库，只需将其添加到您的 Cargo.toml 文件中即可

[dependencies]
grex = { version = "1.4.5", default-features = false }

依赖项 clap 仅用于命令行工具。通过禁用默认功能，防止库中下载和编译 clap。

5. 如何使用？

有关可用设置的详细说明请参阅 库部分。所有设置都可以自由组合。

5.1 命令行工具

测试用例可以通过直接传递（grex a b c）或从文件中传递（grex -f test_cases.txt）。grex 还可以从 Unix 管道接收输入，例如 cat test_cases.txt | grex -。

以下表格显示了所有可用的标志和选项

$ grex -h

grex 1.4.5
© 2019-today Peter M. Stahl <[email protected]>
Licensed under the Apache License, Version 2.0
Downloadable from https://crates.io/crates/grex
Source code at https://github.com/pemistahl/grex

grex generates regular expressions from user-provided test cases.

Usage: grex [OPTIONS] {INPUT...|--file <FILE>}

Input:
  [INPUT]...         One or more test cases separated by blank space
  -f, --file <FILE>  Reads test cases on separate lines from a file

Digit Options:
  -d, --digits      Converts any Unicode decimal digit to \d
  -D, --non-digits  Converts any character which is not a Unicode decimal digit to \D

Whitespace Options:
  -s, --spaces      Converts any Unicode whitespace character to \s
  -S, --non-spaces  Converts any character which is not a Unicode whitespace character to \S

Word Options:
  -w, --words      Converts any Unicode word character to \w
  -W, --non-words  Converts any character which is not a Unicode word character to \W

Escaping Options:
  -e, --escape           Replaces all non-ASCII characters with unicode escape sequences
      --with-surrogates  Converts astral code points to surrogate pairs if --escape is set

Repetition Options:
  -r, --repetitions
          Detects repeated non-overlapping substrings and converts them to {min,max} quantifier
          notation
      --min-repetitions <QUANTITY>
          Specifies the minimum quantity of substring repetitions to be converted if --repetitions
          is set [default: 1]
      --min-substring-length <LENGTH>
          Specifies the minimum length a repeated substring must have in order to be converted if
          --repetitions is set [default: 1]

Anchor Options:
      --no-start-anchor  Removes the caret anchor `^` from the resulting regular expression
      --no-end-anchor    Removes the dollar sign anchor `$` from the resulting regular expression
      --no-anchors       Removes the caret and dollar sign anchors from the resulting regular
                         expression

Display Options:
  -x, --verbose   Produces a nicer-looking regular expression in verbose mode
  -c, --colorize  Provides syntax highlighting for the resulting regular expression

Miscellaneous Options:
  -i, --ignore-case     Performs case-insensitive matching, letters match both upper and lower case
  -g, --capture-groups  Replaces non-capturing groups with capturing ones
  -h, --help            Prints help information
  -v, --version         Prints version information

 

5.2 库

5.2.1 默认设置

测试用例可以通过RegExpBuilder::from()从集合中传递，或者通过RegExpBuilder::from_file()从文件中传递。如果从文件中读取，每个测试用例必须单独一行。行可以以换行符\n或回车换行符\r\n结束。

use grex::RegExpBuilder;

let regexp = RegExpBuilder::from(&["a", "aa", "aaa"]).build();
assert_eq!(regexp, "^a(?:aa?)?$");

5.2.2 转换为字符类

use grex::RegExpBuilder;

let regexp = RegExpBuilder::from(&["a", "aa", "123"])
    .with_conversion_of_digits()
    .with_conversion_of_words()
    .build();
assert_eq!(regexp, "^(\\d\\d\\d|\\w(?:\\w)?)$");

5.2.3 转换重复的子串

use grex::RegExpBuilder;

let regexp = RegExpBuilder::from(&["aa", "bcbc", "defdefdef"])
    .with_conversion_of_repetitions()
    .build();
assert_eq!(regexp, "^(?:a{2}|(?:bc){2}|(?:def){3})$");

默认情况下，grex会以这种方式转换每个至少包含一个字符且至少重复一次的子串。如果您喜欢，可以自定义这两个参数。

在下面的示例中，测试用例aa不会被转换为a{2}，因为重复的子串a的长度为1，但最小子串长度已被设置为2。

use grex::RegExpBuilder;

let regexp = RegExpBuilder::from(&["aa", "bcbc", "defdefdef"])
    .with_conversion_of_repetitions()
    .with_minimum_substring_length(2)
    .build();
assert_eq!(regexp, "^(?:aa|(?:bc){2}|(?:def){3})$");

在下一个示例中，设置最小重复次数为2，只有测试用例defdefdef会被转换，因为它是唯一重复两次的。

use grex::RegExpBuilder;

let regexp = RegExpBuilder::from(&["aa", "bcbc", "defdefdef"])
    .with_conversion_of_repetitions()
    .with_minimum_repetitions(2)
    .build();
assert_eq!(regexp, "^(?:bcbc|aa|(?:def){3})$");

5.2.4 转义非ASCII字符

use grex::RegExpBuilder;

let regexp = RegExpBuilder::from(&["You smell like 💩."])
    .with_escaping_of_non_ascii_chars(false)
    .build();
assert_eq!(regexp, "^You smell like \\u{1f4a9}\\.$");

旧版本的JavaScript不支持天体代码平面的Unicode转义序列（范围U+010000到U+10FFFF）。为了在JavaScript正则表达式中支持这些符号，需要进行代理对转换。有关更多信息，请参阅这里。

use grex::RegExpBuilder;

let regexp = RegExpBuilder::from(&["You smell like 💩."])
    .with_escaped_non_ascii_chars(true)
    .build();
assert_eq!(regexp, "^You smell like \\u{d83d}\\u{dca9}\\.$");

use grex::RegExpBuilder;

let regexp = RegExpBuilder::from(&["big", "BIGGER"])
    .with_case_insensitive_matching()
    .build();
assert_eq!(regexp, "(?i)^big(?:ger)?$");

use grex::RegExpBuilder;

let regexp = RegExpBuilder::from(&["big", "BIGGER"])
    .with_case_insensitive_matching()
    .with_capturing_groups()
    .build();
assert_eq!(regexp, "(?i)^big(ger)?$");

use grex::RegExpBuilder;
use indoc::indoc;

let regexp = RegExpBuilder::from(&["a", "b", "bcd"])
    .with_verbose_mode()
    .build();

assert_eq!(regexp, indoc!(
    r#"
    (?x)
    ^
      (?:
        b
        (?:
          cd
        )?
        |
        a
      )
    $"#
));

use grex::RegExpBuilder;

let regexp = RegExpBuilder::from(&["a", "aa", "aaa"])
    .without_anchors()
    .build();
assert_eq!(regexp, "a(?:aa?)?");

$ grex a b c
^[a-c]$

$ grex a c d e f
^[ac-f]$

$ grex a b x de
^(?:de|[abx])$

$ grex abc bc
^a?bc$

$ grex a b bc
^(?:bc?|a)$

$ grex [a-z]
^\[a\-z\]$

$ grex -r b ba baa baaa
^b(?:a{1,3})?$

$ grex -r b ba baa baaaa
^b(?:a{1,2}|a{4})?$

$ grex y̆ a z
^(?:y̆|[az])$
Note: 
Grapheme y̆ consists of two Unicode symbols:
U+0079 (Latin Small Letter Y)
U+0306 (Combining Breve)

$ grex "I ♥ cake" "I ♥ cookies"
^I ♥ c(?:ookies|ake)$
Note:
Input containing blank space must be 
surrounded by quotation marks.

$ grex <INPUT>
^I ♥♥♥ 36 and ٣ and 💩💩\.$

$ grex -e <INPUT>
^I \u{2665}\u{2665}\u{2665} 36 and \u{663} and \u{1f4a9}\u{1f4a9}\.$

$ grex -e --with-surrogates <INPUT>
^I \u{2665}\u{2665}\u{2665} 36 and \u{663} and \u{d83d}\u{dca9}\u{d83d}\u{dca9}\.$

$ grex -d <INPUT>
^I ♥♥♥ \d\d and \d and 💩💩\.$

$ grex -s <INPUT>
^I\s♥♥♥\s36\sand\s٣\sand\s💩💩\.$

$ grex -w <INPUT>
^\w ♥♥♥ \w\w \w\w\w \w \w\w\w 💩💩\.$

$ grex -D <INPUT>
^\D\D\D\D\D\D36\D\D\D\D\D٣\D\D\D\D\D\D\D\D$

$ grex -S <INPUT>
^\S \S\S\S \S\S \S\S\S \S \S\S\S \S\S\S$

$ grex -dsw <INPUT>
^\w\s♥♥♥\s\d\d\s\w\w\w\s\d\s\w\w\w\s💩💩\.$

$ grex -dswW <INPUT>
^\w\s\W\W\W\s\d\d\s\w\w\w\s\d\s\w\w\w\s\W\W\W$

$ grex -r <INPUT>
^I ♥{3} 36 and ٣ and 💩{2}\.$

$ grex -er <INPUT>
^I \u{2665}{3} 36 and \u{663} and \u{1f4a9}{2}\.$

$ grex -er --with-surrogates <INPUT>
^I \u{2665}{3} 36 and \u{663} and (?:\u{d83d}\u{dca9}){2}\.$

$ grex -dgr <INPUT>
^I ♥{3} \d(\d and ){2}💩{2}\.$

$ grex -rs <INPUT>
^I\s♥{3}\s36\sand\s٣\sand\s💩{2}\.$

$ grex -rw <INPUT>
^\w ♥{3} \w(?:\w \w{3} ){2}💩{2}\.$

$ grex -Dr <INPUT>
^\D{6}36\D{5}٣\D{8}$

$ grex -rS <INPUT>
^\S \S(?:\S{2} ){2}\S{3} \S \S{3} \S{3}$

$ grex -rW <INPUT>
^I\W{5}36\Wand\W٣\Wand\W{4}$

$ grex -drsw <INPUT>
^\w\s♥{3}\s\d(?:\d\s\w{3}\s){2}💩{2}\.$

$ grex -drswW <INPUT>
^\w\s\W{3}\s\d(?:\d\s\w{3}\s){2}\W{3}$

git clone https://github.com/pemistahl/grex.git
cd grex
cargo build

cargo test

cargo bench

pip install grex

python -m venv /path/to/virtual/environment
source /path/to/virtual/environment/bin/activate
pip install maturin
maturin build

from grex import RegExpBuilder

wasm-pack build --target web

<script type="module">
    import init, { RegExpBuilder } from "./pkg/grex.js";

    init().then(_ => {
        alert(RegExpBuilder.from(["hello", "world"]).build());
    });
</script>

wasm-pack test --node --headless --chrome --firefox --safari

sudo safaridriver --enable