use single backtick (#17115)
This commit is contained in:
flywind
GitHub
parent
1efaef52a2
commit
a1a18cfe66
10 changed files with 174 additions and 174 deletions
|
|
@ -20,7 +20,7 @@ when defined(js):
|
|||
## search the internet for a wide variety of third-party documentation and
|
||||
## tools.
|
||||
##
|
||||
## **Note**: If you love ``sequtils.toSeq`` we have bad news for you. This
|
||||
## **Note**: If you love `sequtils.toSeq` we have bad news for you. This
|
||||
## library doesn't work with it due to documented compiler limitations. As
|
||||
## a workaround, use this:
|
||||
##
|
||||
|
|
@ -76,19 +76,19 @@ export options
|
|||
type
|
||||
Regex* = ref object
|
||||
## Represents the pattern that things are matched against, constructed with
|
||||
## ``re(string)``. Examples: ``re"foo"``, ``re(r"(*ANYCRLF)(?x)foo #
|
||||
## comment".``
|
||||
## `re(string)`. Examples: `re"foo"`, `re(r"(*ANYCRLF)(?x)foo #
|
||||
## comment".`
|
||||
##
|
||||
## ``pattern: string``
|
||||
## `pattern: string`
|
||||
## the string that was used to create the pattern. For details on how
|
||||
## to write a pattern, please see `the official PCRE pattern
|
||||
## documentation.
|
||||
## <https://www.pcre.org/original/doc/html/pcrepattern.html>`_
|
||||
##
|
||||
## ``captureCount: int``
|
||||
## `captureCount: int`
|
||||
## the number of captures that the pattern has.
|
||||
##
|
||||
## ``captureNameId: Table[string, int]``
|
||||
## `captureNameId: Table[string, int]`
|
||||
## a table from the capture names to their numeric id.
|
||||
##
|
||||
##
|
||||
|
|
@ -98,30 +98,30 @@ type
|
|||
## The following options may appear anywhere in the pattern, and they affect
|
||||
## the rest of it.
|
||||
##
|
||||
## - ``(?i)`` - case insensitive
|
||||
## - ``(?m)`` - multi-line: ``^`` and ``$`` match the beginning and end of
|
||||
## - `(?i)` - case insensitive
|
||||
## - `(?m)` - multi-line: `^` and `$` match the beginning and end of
|
||||
## lines, not of the subject string
|
||||
## - ``(?s)`` - ``.`` also matches newline (*dotall*)
|
||||
## - ``(?U)`` - expressions are not greedy by default. ``?`` can be added
|
||||
## - `(?s)` - `.` also matches newline (*dotall*)
|
||||
## - `(?U)` - expressions are not greedy by default. `?` can be added
|
||||
## to a qualifier to make it greedy
|
||||
## - ``(?x)`` - whitespace and comments (``#``) are ignored (*extended*)
|
||||
## - ``(?X)`` - character escapes without special meaning (``\w`` vs.
|
||||
## ``\a``) are errors (*extra*)
|
||||
## - `(?x)` - whitespace and comments (`#`) are ignored (*extended*)
|
||||
## - `(?X)` - character escapes without special meaning (`\w` vs.
|
||||
## `\a`) are errors (*extra*)
|
||||
##
|
||||
## One or a combination of these options may appear only at the beginning
|
||||
## of the pattern:
|
||||
##
|
||||
## - ``(*UTF8)`` - treat both the pattern and subject as UTF-8
|
||||
## - ``(*UCP)`` - Unicode character properties; ``\w`` matches ``я``
|
||||
## - ``(*U)`` - a combination of the two options above
|
||||
## - ``(*FIRSTLINE*)`` - fails if there is not a match on the first line
|
||||
## - ``(*NO_AUTO_CAPTURE)`` - turn off auto-capture for groups;
|
||||
## ``(?<name>...)`` can be used to capture
|
||||
## - ``(*CR)`` - newlines are separated by ``\r``
|
||||
## - ``(*LF)`` - newlines are separated by ``\n`` (UNIX default)
|
||||
## - ``(*CRLF)`` - newlines are separated by ``\r\n`` (Windows default)
|
||||
## - ``(*ANYCRLF)`` - newlines are separated by any of the above
|
||||
## - ``(*ANY)`` - newlines are separated by any of the above and Unicode
|
||||
## - `(*UTF8)` - treat both the pattern and subject as UTF-8
|
||||
## - `(*UCP)` - Unicode character properties; `\w` matches `я`
|
||||
## - `(*U)` - a combination of the two options above
|
||||
## - `(*FIRSTLINE*)` - fails if there is not a match on the first line
|
||||
## - `(*NO_AUTO_CAPTURE)` - turn off auto-capture for groups;
|
||||
## `(?<name>...)` can be used to capture
|
||||
## - `(*CR)` - newlines are separated by `\r`
|
||||
## - `(*LF)` - newlines are separated by `\n` (UNIX default)
|
||||
## - `(*CRLF)` - newlines are separated by `\r\n` (Windows default)
|
||||
## - `(*ANYCRLF)` - newlines are separated by any of the above
|
||||
## - `(*ANY)` - newlines are separated by any of the above and Unicode
|
||||
## newlines:
|
||||
##
|
||||
## single characters VT (vertical tab, U+000B), FF (form feed, U+000C),
|
||||
|
|
@ -130,8 +130,8 @@ type
|
|||
## are recognized only in UTF-8 mode.
|
||||
## — man pcre
|
||||
##
|
||||
## - ``(*JAVASCRIPT_COMPAT)`` - JavaScript compatibility
|
||||
## - ``(*NO_STUDY)`` - turn off studying; study is enabled by default
|
||||
## - `(*JAVASCRIPT_COMPAT)` - JavaScript compatibility
|
||||
## - `(*NO_STUDY)` - turn off studying; study is enabled by default
|
||||
##
|
||||
## For more details on the leading option groups, see the `Option
|
||||
## Setting <http://man7.org/linux/man-pages/man3/pcresyntax.3.html#OPTION_SETTING>`_
|
||||
|
|
@ -141,9 +141,9 @@ type
|
|||
## manual <http://man7.org/linux/man-pages/man3/pcresyntax.3.html>`_.
|
||||
##
|
||||
## Some of these options are not part of PCRE and are converted by nre
|
||||
## into PCRE flags. These include ``NEVER_UTF``, ``ANCHORED``,
|
||||
## ``DOLLAR_ENDONLY``, ``FIRSTLINE``, ``NO_AUTO_CAPTURE``,
|
||||
## ``JAVASCRIPT_COMPAT``, ``U``, ``NO_STUDY``. In other PCRE wrappers, you
|
||||
## into PCRE flags. These include `NEVER_UTF`, `ANCHORED`,
|
||||
## `DOLLAR_ENDONLY`, `FIRSTLINE`, `NO_AUTO_CAPTURE`,
|
||||
## `JAVASCRIPT_COMPAT`, `U`, `NO_STUDY`. In other PCRE wrappers, you
|
||||
## will need to pass these as separate flags to PCRE.
|
||||
pattern*: string ## not nil
|
||||
pcreObj: ptr pcre.Pcre ## not nil
|
||||
|
|
@ -155,46 +155,46 @@ type
|
|||
## Usually seen as Option[RegexMatch], it represents the result of an
|
||||
## execution. On failure, it is none, on success, it is some.
|
||||
##
|
||||
## ``pattern: Regex``
|
||||
## `pattern: Regex`
|
||||
## the pattern that is being matched
|
||||
##
|
||||
## ``str: string``
|
||||
## `str: string`
|
||||
## the string that was matched against
|
||||
##
|
||||
## ``captures[]: string``
|
||||
## `captures[]: string`
|
||||
## the string value of whatever was captured at that id. If the value
|
||||
## is invalid, then behavior is undefined. If the id is ``-1``, then
|
||||
## is invalid, then behavior is undefined. If the id is `-1`, then
|
||||
## the whole match is returned. If the given capture was not matched,
|
||||
## ``nil`` is returned.
|
||||
## `nil` is returned.
|
||||
##
|
||||
## - ``"abc".match(re"(\w)").get.captures[0] == "a"``
|
||||
## - ``"abc".match(re"(?<letter>\w)").get.captures["letter"] == "a"``
|
||||
## - ``"abc".match(re"(\w)\w").get.captures[-1] == "ab"``
|
||||
## - `"abc".match(re"(\w)").get.captures[0] == "a"`
|
||||
## - `"abc".match(re"(?<letter>\w)").get.captures["letter"] == "a"`
|
||||
## - `"abc".match(re"(\w)\w").get.captures[-1] == "ab"`
|
||||
##
|
||||
## ``captureBounds[]: HSlice[int, int]``
|
||||
## `captureBounds[]: HSlice[int, int]`
|
||||
## gets the bounds of the given capture according to the same rules as
|
||||
## the above. If the capture is not filled, then ``None`` is returned.
|
||||
## the above. If the capture is not filled, then `None` is returned.
|
||||
## The bounds are both inclusive.
|
||||
##
|
||||
## - ``"abc".match(re"(\w)").get.captureBounds[0] == 0 .. 0``
|
||||
## - ``0 in "abc".match(re"(\w)").get.captureBounds == true``
|
||||
## - ``"abc".match(re"").get.captureBounds[-1] == 0 .. -1``
|
||||
## - ``"abc".match(re"abc").get.captureBounds[-1] == 0 .. 2``
|
||||
## - `"abc".match(re"(\w)").get.captureBounds[0] == 0 .. 0`
|
||||
## - `0 in "abc".match(re"(\w)").get.captureBounds == true`
|
||||
## - `"abc".match(re"").get.captureBounds[-1] == 0 .. -1`
|
||||
## - `"abc".match(re"abc").get.captureBounds[-1] == 0 .. 2`
|
||||
##
|
||||
## ``match: string``
|
||||
## `match: string`
|
||||
## the full text of the match.
|
||||
##
|
||||
## ``matchBounds: HSlice[int, int]``
|
||||
## the bounds of the match, as in ``captureBounds[]``
|
||||
## `matchBounds: HSlice[int, int]`
|
||||
## the bounds of the match, as in `captureBounds[]`
|
||||
##
|
||||
## ``(captureBounds|captures).toTable``
|
||||
## `(captureBounds|captures).toTable`
|
||||
## returns a table with each named capture as a key.
|
||||
##
|
||||
## ``(captureBounds|captures).toSeq``
|
||||
## `(captureBounds|captures).toSeq`
|
||||
## returns all the captures by their number.
|
||||
##
|
||||
## ``$: string``
|
||||
## same as ``match``
|
||||
## `$: string`
|
||||
## same as `match`
|
||||
pattern*: Regex ## The regex doing the matching.
|
||||
## Not nil.
|
||||
str*: string ## The string that was matched against.
|
||||
|
|
@ -549,14 +549,14 @@ proc match*(str: string, pattern: Regex, start = 0, endpos = int.high): Option[R
|
|||
|
||||
iterator findIter*(str: string, pattern: Regex, start = 0, endpos = int.high): RegexMatch =
|
||||
## Works the same as `find(...)<#find,string,Regex,int>`_, but finds every
|
||||
## non-overlapping match. ``"2222".find(re"22")`` is ``"22", "22"``, not
|
||||
## ``"22", "22", "22"``.
|
||||
## non-overlapping match. `"2222".find(re"22")` is `"22", "22"`, not
|
||||
## `"22", "22", "22"`.
|
||||
##
|
||||
## Arguments are the same as `find(...)<#find,string,Regex,int>`_
|
||||
##
|
||||
## Variants:
|
||||
##
|
||||
## - ``proc findAll(...)`` returns a ``seq[string]``
|
||||
## - `proc findAll(...)` returns a `seq[string]`
|
||||
# see pcredemo for explanation
|
||||
let matchesCrLf = pattern.matchesCrLf()
|
||||
let unicode = uint32(getinfo[culong](pattern, pcre.INFO_OPTIONS) and
|
||||
|
|
@ -601,12 +601,12 @@ proc find*(str: string, pattern: Regex, start = 0, endpos = int.high): Option[Re
|
|||
## Finds the given pattern in the string between the end and start
|
||||
## positions.
|
||||
##
|
||||
## ``start``
|
||||
## The start point at which to start matching. ``|abc`` is ``0``;
|
||||
## ``a|bc`` is ``1``
|
||||
## `start`
|
||||
## The start point at which to start matching. `|abc` is `0`;
|
||||
## `a|bc` is `1`
|
||||
##
|
||||
## ``endpos``
|
||||
## The maximum index for a match; ``int.high`` means the end of the
|
||||
## `endpos`
|
||||
## The maximum index for a match; `int.high` means the end of the
|
||||
## string, otherwise it’s an inclusive upper bound.
|
||||
return str.matchImpl(pattern, start, endpos, 0)
|
||||
|
||||
|
|
@ -618,7 +618,7 @@ proc findAll*(str: string, pattern: Regex, start = 0, endpos = int.high): seq[st
|
|||
proc contains*(str: string, pattern: Regex, start = 0, endpos = int.high): bool =
|
||||
## Determine if the string contains the given pattern between the end and
|
||||
## start positions:
|
||||
## This function is equivalent to ``isSome(str.find(pattern, start, endpos))``.
|
||||
## This function is equivalent to `isSome(str.find(pattern, start, endpos))`.
|
||||
##
|
||||
runnableExamples:
|
||||
doAssert "abc".contains(re"bc")
|
||||
|
|
@ -631,7 +631,7 @@ proc split*(str: string, pattern: Regex, maxSplit = -1, start = 0): seq[string]
|
|||
## Splits the string with the given regex. This works according to the
|
||||
## rules that Perl and Javascript use.
|
||||
##
|
||||
## ``start`` behaves the same as in `find(...)<#find,string,Regex,int>`_.
|
||||
## `start` behaves the same as in `find(...)<#find,string,Regex,int>`_.
|
||||
##
|
||||
runnableExamples:
|
||||
# - If the match is zero-width, then the string is still split:
|
||||
|
|
@ -641,8 +641,8 @@ proc split*(str: string, pattern: Regex, maxSplit = -1, start = 0): seq[string]
|
|||
# split:
|
||||
doAssert "12".split(re"(\d)") == @["", "1", "", "2", ""]
|
||||
|
||||
# - If ``maxsplit != -1``, then the string will only be split
|
||||
# ``maxsplit - 1`` times. This means that there will be ``maxsplit``
|
||||
# - If `maxsplit != -1`, then the string will only be split
|
||||
# `maxsplit - 1` times. This means that there will be `maxsplit`
|
||||
# strings in the output seq.
|
||||
doAssert "1.2.3".split(re"\.", maxsplit = 2) == @["1", "2.3"]
|
||||
|
||||
|
|
@ -708,28 +708,28 @@ template replaceImpl(str: string, pattern: Regex,
|
|||
|
||||
proc replace*(str: string, pattern: Regex,
|
||||
subproc: proc (match: RegexMatch): string): string =
|
||||
## Replaces each match of Regex in the string with ``subproc``, which should
|
||||
## never be or return ``nil``.
|
||||
## Replaces each match of Regex in the string with `subproc`, which should
|
||||
## never be or return `nil`.
|
||||
##
|
||||
## If ``subproc`` is a ``proc (RegexMatch): string``, then it is executed with
|
||||
## If `subproc` is a `proc (RegexMatch): string`, then it is executed with
|
||||
## each match and the return value is the replacement value.
|
||||
##
|
||||
## If ``subproc`` is a ``proc (string): string``, then it is executed with the
|
||||
## If `subproc` is a `proc (string): string`, then it is executed with the
|
||||
## full text of the match and and the return value is the replacement
|
||||
## value.
|
||||
##
|
||||
## If ``subproc`` is a string, the syntax is as follows:
|
||||
## If `subproc` is a string, the syntax is as follows:
|
||||
##
|
||||
## - ``$$`` - literal ``$``
|
||||
## - ``$123`` - capture number ``123``
|
||||
## - ``$foo`` - named capture ``foo``
|
||||
## - ``${foo}`` - same as above
|
||||
## - ``$1$#`` - first and second captures
|
||||
## - ``$#`` - first capture
|
||||
## - ``$0`` - full match
|
||||
## - `$$` - literal `$`
|
||||
## - `$123` - capture number `123`
|
||||
## - `$foo` - named capture `foo`
|
||||
## - `${foo}` - same as above
|
||||
## - `$1$#` - first and second captures
|
||||
## - `$#` - first capture
|
||||
## - `$0` - full match
|
||||
##
|
||||
## If a given capture is missing, ``IndexDefect`` thrown for un-named captures
|
||||
## and ``KeyError`` for named captures.
|
||||
## If a given capture is missing, `IndexDefect` thrown for un-named captures
|
||||
## and `KeyError` for named captures.
|
||||
replaceImpl(str, pattern, subproc(match))
|
||||
|
||||
proc replace*(str: string, pattern: Regex,
|
||||
|
|
@ -743,7 +743,7 @@ proc replace*(str: string, pattern: Regex, sub: string): string =
|
|||
|
||||
proc escapeRe*(str: string): string {.gcsafe.} =
|
||||
## Escapes the string so it doesn't match any special characters.
|
||||
## Incompatible with the Extra flag (``X``).
|
||||
## Incompatible with the Extra flag (`X`).
|
||||
##
|
||||
## Escaped char: `\ + * ? [ ^ ] $ ( ) { } = ! < > | : -`
|
||||
runnableExamples:
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue