update completions and changelog

Aloso · Aloso · commit 8136ab3a498a · 2025-11-03T15:11:35.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,68 +7,84 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### New
+## [0.12.0] - TBD
 
-- Support for the RE2 flavor
+### New
 
-- Intersection of character sets. For example, `[Letter] & [Latin]` matches a letter that is also in the Latin script.
+- [RE2](https://github.com/google/re2) flavor added
 
-- Character class prefixes: `gc:` (general category), `sc:` (script), `scx:` (script extension), `blk:` (blocks).
-  For example, `[scx:Syriac]` matches all characters with the Syriac script extension.
+- [Intersection](https://www.regular-expressions.info/charclassintersect.html) of character sets added, using the new `&` operator:
 
-  - Adds support for script extensions (currently supported in PCRE, JavaScript, and Rust)
-  - If the `blk:` prefix is used, `In` must be removed; e.g. `[InPrivate_Use]` becomes `[blk:Private_Use]`
-  - Writing the prefix is optional, except for script extensions
+  ```pomsky
+  [Thai] & [Nd] # equivalent to the regex [\p{Thai}&&\p{Nd}]
+  ```
 
-- A `pomsky test` subcommand for running unit tests
+  Note that subtraction can be achieved by negating the character set to be subtracted:
 
-  - Two supported regex engines for testing: `pcre2` and `rust`
-  - The `--test` argument is now deprecated
+  ```pomsky
+  [Thai] & ![Nd] # equivalent to the regex [\p{Thai}--\p{Nd}]
+  ```
 
-- Many optimizations (see below)
+- Match [Script Extensions](https://www.unicode.org/L2/L2011/11406-script-ext.html), using the `scx:` or `script_extensions:` prefix:
 
-### Changed
+  ```pomsky
+  [scx:Syriac]
+  ```
 
-- Change hygiene of `lazy` and `unicode` mode to behave as one would expect.
-  Going forward, modes depend on the scope where an expression is defined, not where it is used:
+  Other Unicode properties also get optional prefixes:
 
   ```pomsky
-  let foo = 'foo'*;  # this repetition is not lazy
-  (enable lazy; foo)
+  # old         # new         # alternative
+  [Latin]       [sc:Latin]    [script:Latin]
+  [InGreek]     [blk:Greek]   [block:Greek]
+  [Letter]      [gc:Letter]   [general_category:Letter]
   ```
 
-- Increase the maximum length of group names from 32 to 128 characters.
-  Group names this long are supported in PCRE2 since version 10.44.
+  Note that for the `In` prefix of Unicode blocks is omitted when the `blk:` or `block:` prefix is used. Unicode blocks with `In` instead of `blk:` will be deprecated.
 
-- Produce an error if the contents of a lookbehind assertion are not supported by the regex flavor (Java, Python, PCRE)
+- `pomsky test` subcommand added to compile and test all `*.pomsky` files in a directory. This command ignores files matched by a `.ignore` or `.gitignore` file. For help, run `pomsky test --help`.
 
-- Produce an error if infinite recursion is detected
+- Unit tests can now be run with the Rust `regex` crate. To use it, specify `--flavor=rust` or `--engine=rust`.
 
-- Remove the compatibility warning for lookbehind in JavaScript.
-  Lookbehind is now widely supported in JavaScript engines.
+- Diagnostic to detect infinite recursion. If a recursive expression can never terminate, an error is shown.
 
-- Allow all supported boolean Unicode properties in the Java flavor
+### Changes
 
-- Deprecate the `--test` argument; use `pomsky test -p <PATH>` instead
+- `lazy` and `unicode` mode is no longer inherited when expanding variables.
 
-### Optimizations
+  > [!IMPORTANT]  
+  > This changes the meaning of expressions such as this:
+  >
+  > ```pomsky
+  > let variable = 'test'*;
+  > enable lazy;
+  > variable
+  > ```
+  >
+  > Before Pomsky 0.12, the repetition was lazy, but now it isn't.
 
-- De-duplicate and merge character ranges: `['b' 'a'-'f' 'c'-'m']` becomes `[a-m]`
+  The `enable` or `disable` statement has to appear before the repetition _syntactically_, it doesn't matter where the variable is used. The old behavior was too unintuitive and easy to mess up, so we fixed it.
 
-  - Note that this doesn't work with Unicode classes, e.g. `Alphabetic`
+- Optimize single-character alternatives, and merge adjacent or overlapping ranges.
 
-- Merge common alternation prefixes: `'do' | 'double' | 'down'` becomes `do(?:uble|wn)??`
+  For example, `'a' | ['bc'] | ['f'-'i']` is optimized to `[a-cf-i]`.
 
-  - This only works with string literals and character sets, for now
-  - Only adjacent alternatives can be merged to ensure that precedence isn't affected
+  > [!NOTE]  
+  > The order of character ranges in a set is no longer preserved. Currently, they are sorted in ascending order; for example, `['x' 'X' 'A'-'F' 'a'-'f']` becomes `[A-FXa-fx]`.
 
-- Combine single-character alternations into a set: `'a' | 'b' | 'c' | 'f'` becomes `[a-cf]`
+- No longer warn about lookbehind in JavaScript. Lookbehind is now widely supported.
 
-- Merge constant nested repetitions: `('a'{3}){4}` becomes `a{12}`
+- Update Unicode support data for properties added in Unicode 15.x
 
-### Bugfixes
+### Fixes
+
+- Allow supported Unicode binary properties in Java (previously, binary properties in Java were unsupported)
+
+- Link PCRE2 statically (previously it was linked dynamically, which doesn't work if PCRE2 isn't installed on the target system)
+
+- Allow Unicode blocks in Ruby, but not PCRE
 
-- Do not miscompile `[r]`
+- Output `[r]` as `\r`, not as `\n` (this was a bug introduced by normalizing verbatim line endings in strings).
 
 ## [0.11.0] - 2023-11-09
 
diff --git a/completions/pomsky.bash b/completions/pomsky.bash
@@ -1,32 +1,53 @@
 _complete_pomsky()
 {
-    local flavors="pcre python java js dotnet ruby rust"
-    local flavors_concat="-fpcre -fpython -fjava -fjs -fdotnet -fruby -frust"
+    local flavors="pcre python java js dotnet ruby rust re2"
+    local flavors_concat="-fpcre -fpython -fjava -fjs -fdotnet -fruby -frust -fre2"
+
+    local engines="pcre2 rust"
+    local engines_concat="-epcre2 -erust"
+
     local warnings="0 compat=0 deprecated=0"
     local warnings_concat="-W0 -Wcompat=0 -Wdeprecated=0"
+
     local features="atomic-groups boundaries dot grapheme lazy-mode lookahead lookbehind named-groups numbered-groups ranges recursion references regexes variables"
-    local flags="--allowed-features --flavor --help --no-new-line --path --test --version --warnings --debug --json --list"
+
+    local flags_and_subcommands="test --allowed-features --flavor --help --no-new-line --path --test --version --warnings --debug --json --list"
+    local test_flags="--allowed-features --engine --flavor --help --pass-with-no-tests --path --version --warnings --debug --json"
 
     local cur=${COMP_WORDS[COMP_CWORD]}
     local prev=${COMP_WORDS[COMP_CWORD - 1]}
 
+    _add_space()
+    {
+        for ((i=0; i < ${#COMPREPLY[@]}; i++)); do
+            COMPREPLY[$i]="${COMPREPLY[$i]} "
+        done
+    }
+
+    _add_space_or_slash()
+    {
+        # add '/' after directories and a space after files
+        for ((i=0; i < ${#COMPREPLY[@]}; i++)); do
+            if [ -d "${COMPREPLY[$i]}" ]; then
+                COMPREPLY[$i]="${COMPREPLY[$i]}/"
+            else
+                COMPREPLY[$i]="${COMPREPLY[$i]} "
+            fi
+        done
+    }
+
     case "$prev" in
         -p | --path)
             COMPREPLY=( $( compgen -o plusdirs -f -- $cur ) )
-
-            # add '/' after directories and a space after files
-            for ((i=0; i < ${#COMPREPLY[@]}; i++)); do
-                if [ -d "${COMPREPLY[$i]}" ]; then
-                    COMPREPLY[$i]="${COMPREPLY[$i]}/"
-                else
-                    COMPREPLY[$i]="${COMPREPLY[$i]} "
-                fi
-            done
+            _add_space_or_slash
             return 0;
             ;;
         -f | --flavor)
             COMPREPLY=( $( compgen -W "$flavors" -- $cur ) )
             ;;
+        -e | --engine)
+            COMPREPLY=( $( compgen -W "$engines" -- $cur ) )
+            ;;
         --list)
             COMPREPLY=( $( compgen -W "shorthands" -- $cur ) )
             ;;
@@ -37,22 +58,28 @@ _complete_pomsky()
             COMPREPLY=( $( compgen -W "$features" -- $cur ) )
             ;;
         --test)
-            COMPREPLY=( $( compgen -W "pcre2" -- $cur ) )
+            COMPREPLY=( $( compgen -W "$engines" -- $cur ) )
             ;;
         *)
             if [[ $cur = -f* ]]; then
                 COMPREPLY=( $( compgen -W "$flavors_concat" -- $cur ) )
+            elif [[ $cur = -e* ]]; then
+                COMPREPLY=( $( compgen -W "$engines_concat" -- $cur ) )
             elif [[ $cur = -W* ]]; then
                 COMPREPLY=( $( compgen -W "$warnings_concat" -- $cur ) )
             else
-                COMPREPLY=( $( compgen -W "$flags" -- $cur ) )
+                for ((i=1; i < $COMP_CWORD; i++)); do
+                    if [[ ${COMP_WORDS[$i]} = test ]]; then
+                        COMPREPLY=( $( compgen -W "$test_flags" -- $cur ) )
+                        _add_space
+                        return 0;
+                    fi
+                done
+                COMPREPLY=( $( compgen -W "$flags_and_subcommands" -- $cur ) )
             fi
             ;;
     esac
 
-    # add a space after each completion
-    for ((i=0; i < ${#COMPREPLY[@]}; i++)); do
-        COMPREPLY[$i]="${COMPREPLY[$i]} "
-    done
+    _add_space
 }
 complete -o nospace -F _complete_pomsky pomsky
diff --git a/completions/pomsky.fish b/completions/pomsky.fish
@@ -1,26 +1,49 @@
 set -l features \
-'ascii-mode atomic-groups boundaries dot grapheme lazy-mode lookahead lookbehind named-groups numbered-groups ranges recursion references regexes variables'
+'ascii-mode atomic-groups boundaries dot grapheme intersection lazy-mode lookahead lookbehind named-groups numbered-groups ranges recursion references regexes variables'
+
 set -l flavors \
 'pcre	PCRE flavor
 python	Python re flavor
 java	Java flavor
 js		JavaScript (ECMAScript) flavor
 dotnet	C# (.NET) flavor
 ruby	Ruby (Oniguruma) flavor
-rust	Rust regex flavor'
+rust	Rust regex flavor
+re2		RE2 flavor'
+
 set -l warnings \
 '0				Disable all warnings
 compat=0		Disable compatibility warnings
 deprecated=0	Disable deprecation warnings'
 
+set -l engines \
+'pcre2	PCRE2 regex engine
+rust	Rust crate `regex`'
+
+set -l subcommands \
+'test	Run unit test suite
+'
+
+# subcommands
+complete -c pomsky -n "not __fish_seen_subcommand_from test" -fa "(echo \"$subcommands\")"
+# disable file completions (-f) for `pomsky test`
+complete -c pomsky -f -n '__fish_seen_subcommand_from test'
+
+# global args
 complete -c pomsky      -l allowed-features -d 'Allowed features, comma-separated' -xa "(__fish_append , $features)"
 complete -c pomsky -s f -l flavor           -d 'Regex flavor' -xa "(echo \"$flavors\")"
 complete -c pomsky -s h -l help             -d 'Show help information'
-complete -c pomsky      -l list             -d 'List shorthands' -xa "shorthands"
-complete -c pomsky -s n -l no-new-line      -d "Don't print line break after the output"
-complete -c pomsky -s p -l path             -d 'File to compile' -kxa "(__fish_complete_suffix .pom)"
-complete -c pomsky      -l test             -d 'Run unit tests' -xa 'pcre2'
+complete -c pomsky -s p -l path             -d 'File or directory' -kxa "(__fish_complete_suffix .pomsky)"
 complete -c pomsky -s V -l version          -d 'Print version information'
 complete -c pomsky -s W -l warnings         -d 'Disable some or all warnings' -xa "(echo \"$warnings\")"
 complete -c pomsky -s d -l debug            -d 'Show debug information'
-complete -c pomsky      -l json             -d 'Return output as JSON'
+complete -c pomsky      -l json             -d 'Return output as JSON'
+
+# test args
+complete -c pomsky -n "__fish_seen_subcommand_from test" -s e -l engine             -d 'Regex engine for unit tests' -xa "(echo \"$engines\")"
+complete -c pomsky -n "__fish_seen_subcommand_from test"      -l pass-with-no-tests -d 'Succeed if path contains no *.pomsky files'
+
+# non-test args
+complete -c pomsky -n "not __fish_seen_subcommand_from test"      -l list        -d 'List shorthands' -xa "shorthands"
+complete -c pomsky -n "not __fish_seen_subcommand_from test" -s n -l no-new-line -d "Don't print line break after the output"
+complete -c pomsky -n "not __fish_seen_subcommand_from test"      -l test        -d 'Run unit tests' -xa "(echo \"$engines\")"
diff --git a/completions/pomsky.zsh b/completions/pomsky.zsh
@@ -1,32 +1,41 @@
 #compdef pomsky
 
+_pomsky_cmds() {
+  local commands=(
+    'test:Run unit test suite'
+  )
+  _describe -t commands 'commands' commands
+}
+
 _pomsky_complete_features() {
-  _values -s , 'features' ascii-mode atomic-groups boundaries dot grapheme lazy-mode lookahead lookbehind named-groups numbered-groups ranges recursion references regexes variables
+  _values -s , 'features' ascii-mode atomic-groups boundaries dot grapheme intersection lazy-mode lookahead lookbehind named-groups numbered-groups ranges recursion references regexes variables
 }
 
 _pomsky_complete_lists() {
-  lists=(
+  local lists=(
     'shorthands:Unicode properties and shorthands'
   )
   _describe -t lists 'lists' lists
 }
 
 _pomsky_complete_engine() {
-  engine=(
-    'pcre2:The PCRE2 regex engine'
+  local engine=(
+    'pcre2:PCRE2 regex engine'
+    'rust:Rust crate `regex`'
   )
   _describe -t engine 'engine' engine
 }
 
 _pomsky_complete_flavor() {
-  flavors=(
+  local flavors=(
     'pcre:PCRE flavor'
     'python:Python re flavor'
     'java:Java flavor'
     'js:JavaScript (ECMAScript) flavor'
     'dotnet:C# (.NET) flavor'
     'ruby:Ruby (oniguruma) flavor'
     'rust:Rust regex flavor'
+    're2:RE2 flavor'
   )
   _describe -t flavors 'flavors' flavors
 }
@@ -36,25 +45,39 @@ _pomsky_complete_path() {
 }
 
 _pomsky_complete_warnings() {
-  warnings=(0 compat=0 deprecated=0)
+  local warnings=(
+    '0:Disable all warnings'
+    'compat=0:Disable compatibility warnings'
+    'deprecated=0:Disable deprecation warnings'
+  )
   _describe -t warnings 'warnings' warnings
 }
 
 _pomsky() {
   local curcontext="$curcontext"
 
-  _arguments -s -w -C \
-    '(--allowed-features)--allowed-features=[Allowed features, comma-separated]: :->features' \
-    '(-f --flavor)'{-f+,--flavor=}'[Regex flavor]: :->flavor' \
-    '(-h --help)'{-h+,--help=}'[Show help information]' \
-    '(--list)--list=[List shorthands]: :->lists' \
-    '(-n --no-new-line)'{-n,--no-new-line}"[Don't print line break after the output]" \
-    '(-p --path)'{-p+,--path=}'[File to compile]: :->path' \
-    '(-test)--test=[Run unit tests]: :->engine' \
-    '(-V --version)'{-V,--version}'[Print version information]' \
-    '(-W --warnings)'{-W+,--warnings=}'[Disable some or all warnings]: :->warnings' \
-    '(-d --debug)'{-d,--debug}'[Show debug information]' \
+  local global_args=(
+    '(--allowed-features)--allowed-features=[Allowed features, comma-separated]: :->features'
+    '(-f --flavor)'{-f+,--flavor=}'[Regex flavor]: :->flavor'
+    '(-h --help)'{-h,--help}'[Show help information]'
+    '(-p --path)'{-p+,--path=}'[File or directory]: :->path'
+    '(-V --version)'{-V,--version}'[Print version information]'
+    '(-W --warnings)'{-W+,--warnings=}'[Disable some or all warnings]: :->warnings'
+    '(-d --debug)'{-d,--debug}'[Show debug information]'
     '(--json)--json[Return output as JSON]'
+  )
+  local test_args=(
+    '(-e --engine)'{-e+,--engine=}'[Regex engine for unit tests]: :->engine'
+    '(--pass-with-no-tests)--pass-with-no-tests[Succeed if path contains no *.pomsky files]'
+  )
+  local non_test_args=(
+    '(--list)--list=[List shorthands]: :->lists'
+    '(-n --no-new-line)'{-n,--no-new-line}"[Don't print line break after the output]"
+    '(--test)--test=[Run unit tests]: :->engine'
+  )
+
+  # emit everything, because I haven't figured out how to do it properly
+  _arguments -s -w -C '1: :_pomsky_cmds' $global_args $non_test_args $test_args
 
   case $state in
     (none) ;;
