摘要

WrapAsYouType是Sublime Text文本编辑器的插件。该插件自动在用户键入时对文件中指定部分执行硬单词换行。例如，WrapAsYouType可以将C++代码块注释（在/*和*/之间）和行注释序列（在//之后）的行限制在80列宽。

请注意，您必须为WrapAsYouType设置“wrap_as_you_type_sections”选项才能使用它；请参阅“快速入门”部分。

目录

• 功能
• 限制
• 安装
• 快速开始
• 描述
• 设置
  • "wrap_as_you_type_sections"
  • 示例，C, C++, Go, Java, JavaScript, Objective-C, PHP, Scala，以及类似语言
  • 示例，Sublime 3和4中的Python
  • 示例，Sublime 2中的Python
  • 示例，Rust
  • 示例，整个文档的换行
  • 示例，CSS
  • 示例，Bash, R, Ruby，以及类似语言
  • 示例，C#
  • 示例，Perl
  • 附加说明
  • "wrap_as_you_type_word_regex"
  • "wrap_as_you_type_space_between_words"
  • "wrap_as_you_type_paragraphs"
  • 示例，动态类型的DocBlocks
  • 示例，静态类型的DocBlocks
  • 示例，Google风格的Python文档字符串
  • "wrap_as_you_type_enter_extends_section"
  • "wrap_as_you_type_passive"
  • "wrap_as_you_type_disabled"
• 与Auto (Hard) Wrap的比较

功能

• 兼容Sublime Text 2, 3, 和4。
• 实时执行硬单词换行。
• 段落中间的更改可能导致其他段落重新排版。
• 能够将单词换行限制在用户指定的部分。使用Sublime scopes标识单词换行部分的边界。
• 保持每个可换行部分的初始缩进。
• 允许具有不同内部缩进级别的不同段落，而不会将文本从一段换行到另一段。
• 允许用户指定每行的开始文本。例如，在C++块注释中，用户可能希望每行以" * "开始。
• 提供额外的设置以进行进一步的自定义。

限制

• 不太可能对自动包裹代码或类似的非文本内容有用。
• 仅在单个选择光标没有任何选择时才操作。
• 会污染撤销历史。
• 如果与其他同时修改文档的Sublime插件一起使用，可能会表现不当。

安装

您可以使用Package Control安装WrapAsYouType插件。如果您还没有安装，请按照https://packagecontrol.sublime.net.cn/installation页面上的说明进行安装。在Sublime中打开命令面板，按Windows或Linux上的Ctrl+Shift+P或在macOS上按Super+Shift+P。选择“Package Control: Install Package”，然后选择“WrapAsYouType”。

或者，您可以手动安装WrapAsYouType，将其下载（克隆）到Sublime安装的packages目录中。您可以通过在菜单栏中选择“偏好设置”> “浏览包...”来找到该目录。

快速入门

安装 WrapAsYouType 后，打开您最喜欢的文件类型的语法特定设置。为此，打开所需类型的文件（例如，一个 *.java 文件）。在菜单栏中，转到“偏好设置”> “设置 - 语法特定”（在Sublime 2中，它是“偏好设置”> “设置 - 更多”> “语法特定 - 用户”）。

然后，将 "wrap_as_you_type_sections" 设置为以下示例值之一。为此，单击以下链接之一，将示例配置复制粘贴到您的语法特定设置中，并保存。

• Bash
• C
• C++
• C#
• CSS
• Go
• Java
• JavaScript
• Objective-C
• Perl
• PHP
• 纯文本
• Sublime 2中的Python
• Sublime 3和4中的Python
• R
• Ruby
• Rust
• Scala
• 其他

描述

WrapAsYouType 自动在文件的指定部分实时执行硬字包裹。例如，WrapAsYouType 可以将包含在块注释（在 /* 和 */ 之间）和行注释序列（在 // 之后）中的 C++ 代码的限制设置为 80 列宽度。

每当文档被修改并且有一个单独的空选择光标时，WrapAsYouType 的“修复”函数就会操作。此函数尝试修复光标周围的字包裹。例如，这可能会有将当前行末尾的文本移动到下一行开头或新行的效果，或将文本从当前行开头移动到上一行末尾，或将文本从下一行开头移动到当前行末尾，并在当前行之后重新格式化整个段落。

WrapAsYouType 允许用户在 "wrap_as_you_type_sections" 设置中指定包裹宽度。如果没有提供该设置的包裹宽度，WrapAsYouType 将回退到 "wrap_width" 设置的值，然后到 "rulers" 设置的第一个元素，然后到 80。

WrapAsYouType 还允许用户指定每行的文本，例如用于 C++ 块注释的 " * " 和用于 C++ 行注释的 "//"。例如

/**
 * This is how a block comment might look in C++ when each line starts with an
 * asterisk.
 */

在给定的行中，当确定包围的文本时，WrapAsYouType 忽略“行开始”字符串前后任何空白。

WrapAsYouType 有“段落”的概念。它只会移动单个段落中的文本，而不会从一个段落移动到另一个段落。默认情况下，如果两行在“行开始”字符串前后都有相同的缩进，那么它们属于同一个段落。

示例

/**
 * Part 1:
 *     This is a description of part 1.  WrapAsYouType will not attempt to move
 *     the word "This" to the end of the line containing "Part 1", because they
 *     are considered to be in different paragraphs.
 * Part 2:
 *     Description of part 2.  There are four paragraphs in this example.
 */

如果一行不以可选空白符开始后跟行开始，则该行不符合折行条件。此外，可折行部分的第一行（例如块注释）不符合折行条件，除非该部分延伸至第一行的开头。WrapAsYouType不会分割单个单词，因此如果某个单词过长，超出了折行宽度，WrapAsYouType将把该单词单独放在一行上。

您可能会发现有时WrapAsYouType 会妨碍到您的输入。例如，您可能正在使用ASCII艺术创建图表，或者您的注释中包含代码示例。在这些情况下，建议您使用 "toggle_wrap_as_you_type" 命令在当前标签页中暂时禁用WrapAsYouType。您可以通过前往“首选项”>“按键绑定”菜单项将其绑定到键组合。

示例

[
    {
        "command": "toggle_wrap_as_you_type",
        "keys": ["super+alt+w"]
    }
]

设置

"wrap_as_you_type_sections"

"wrap_as_you_type_sections" 是一个关键设置，它告知WrapAsYouType 在文档中的哪个位置进行单词折行。您必须设置 "wrap_as_you_type_sections" 才能启用WrapAsYouType。通常，您应该将其作为特定于语法的设置来设置，方法是在菜单栏中转到“首选项”>“设置 - 语法特定”。

示例，C，C++，Go，Java，JavaScript，Objective-C，PHP，Scala以及类似语言

{
    "wrap_as_you_type_sections": [
        {
            "allowed_line_starts": ["* ", "*\t"],
            "selector":
                "comment.block - (punctuation.definition.comment.begin | punctuation.definition.comment.end)"
        },
        {
            "combining_selector":
                "source - (comment | constant | entity | invalid | keyword | punctuation | storage | string | variable)",
            "line_start": "//",
            "selector": "comment.line"
        }
    ]
}

"wrap_as_you_type_sections" 是一个对象数组。每个元素具有以下条目

• "line_start"（可选）：每行开始显示的文本，如上“描述”部分中所述。默认为空字符串 ""。注意，对于单行注释部分的设置应指定以行注释标点符号开始（如上述示例中的"//"）的值。
• "allowed_line_starts"（可选）：允许的 "line_start" 值的非空列表。有关详细信息，请参阅Rust示例。包含 "allowed_line_starts" 条目和 "line_start" 条目是错误的。
• "wrap_width"（可选）：此部分类型的折行宽度。
• "selector"：用于识别该部分中的文本的选取器。下面将详细介绍。
• "combining_selector"（可选）：用于扩展部分的选取器。下面将详细介绍。

使用Sublime选取器描述部分的定位。一个选取器表示是否匹配一组 作用域名称。例如，一个选取器可以用来确定作用域 "source.c++ meta.class.c++ meta.block.c++ comment.block.c" 是否匹配。要查看文档中指定点的作用域名称，请使用 "show_scope_name" 命令。默认情况下，它在Windows和Linux上是Ctrl+Alt+Shift+P，在macOS上是Ctrl+Shift+P。

一个简单的选取器（如"comment.block"）会匹配作用域，如果作用域名称中任何一个等于选取器，或者以选取器后跟点开始。可以使用 |（或）、&（和）和-（减去），以及括号将简单选取器组合成复杂选取器。

要确定给定的起始位置是否在给定的部分内部，我们检查它是否与"selector"条目匹配。从那里，部分向前向后扩展，包括也匹配"selector"条目或（如果有）匹配"combining_selector"条目的位置。一旦我们到达不匹配任何一个选取器的位置，部分就不再向前向后扩展。

设置单独的 "combining_selector" 项的动机是在缩进的单行注释序列中实现文本换行。单行注释本身匹配 "comment.line" 选择器，但缩进不匹配该选择器。我们必须有一种方法将这些注释视为一个单一组合部分；因此，"combining_selector"。

上述 "wrap_as_you_type_sections" 的示例值说明了如何将连续的行注释合并为一个单独的章节。"combining_selector" 项匹配不包含各种代码元素的源代码；也就是说，它只匹配空白。这指示 WrapAsYouType 将仅由空白分隔的行注释序列合并为一个单独的分段。

示例，Sublime 3 和 4 中的 Python

{
    "wrap_as_you_type_sections": [
        {
            "selector": "comment.block - punctuation.definition.comment",
            "wrap_width": 72
        },
        {
            "combining_selector":
                "source - (comment | constant | entity | invalid | keyword | punctuation | storage | string | variable)",
            "line_start": "#",
            "selector": "comment.line",
            "wrap_width": 79
        }
    ],
    "wrap_as_you_type_paragraphs": [
        {
            "first_line_regex": "^(\"\"?|''?)$",
            "single_line": true
        }
    ]
}

此示例适用于 Sublime Text 3 和 4 版本的 Python 文件。在此，我们为块注释和行注释指定不同的 "wrap_width" 值。这样，我们将在 79 个字符处换行行注释，在 72 个字符处换行块注释，如 PEP 8 中的建议。

请注意，在 Python 中，建议在打开 """ 的同一行开始起一个块注释，简单描述注释的元素。使用上述配置，WrapAsYouType 不会在该摘要上执行换行，因为 WrapAsYouType 不对章节的第一行进行换行，除非该章节包含整个第一行。

示例，Sublime 2 中的 Python

{
    "wrap_as_you_type_sections": [
        {
            "selector":
                "(string.quoted.double.block | string.quoted.single.block) - punctuation.definition.string",
            "wrap_width": 72
        },
        {
            "combining_selector":
                "source - (comment | constant | entity | invalid | keyword | punctuation | storage | string | variable)",
            "line_start": "#",
            "selector": "comment.line",
            "wrap_width": 79
        }
    ],
    "wrap_as_you_type_paragraphs": [
        {
            "first_line_regex": "^(\"\"?|''?)$",
            "single_line": true
        }
    ]
}

Sublime Text 2 中的 Python 版本内置语法文件并不将文档字符串注释作为 "comment.block" 进行作用域，因此我们需要使用 "string.quoted.*.block" 选择器。这会产生副作用，导致 WrapAsYouType 换行所有三重引号字符串，而不仅仅是文档字符串。

示例，Rust

{
    "wrap_as_you_type_sections": [
        {
            "allowed_line_starts": ["* ", "*\t"],
            "selector":
                "comment.block - (punctuation.definition.comment.begin | punctuation.definition.comment.end)"
        },
        {
            "allowed_line_starts": ["// ", "/// ", "//! "],
            "combining_selector":
                "source - (comment | constant | entity | invalid | keyword | punctuation | storage | string | variable)",
            "selector": "comment.line"
        }
    ]
}

"allowed_line_starts" 项允许我们指定一个分段对象的多种可能的行起始方式。从逻辑上讲，这样的分段对象描述了多种不同的分段类型：每种可能的行起始对应一个。在上面的示例中，WrapAsYouType 区分了双斜杠、三斜杠和双斜杠-感叹号注释。它不会在具有不同行起始的相邻分段之间移动文本，例如，从三斜杠注释移至双斜杠注释。

根据 "wrap_as_you_type_sections" 的值，选择光标可能在给定的分段类型中匹配多个允许的行起始，或者匹配多个分段类型。如果发生这种情况，WrapAsYouType 使用最早匹配的分段类型中最早匹配的行起始。

示例，全文换行

{
    "wrap_as_you_type_sections": [{"selector": "source | text"}]
}

示例，CSS

{
    "wrap_as_you_type_sections": [
        {
            "allowed_line_starts": ["* ", "*\t"],
            "selector":
                "comment.block - (punctuation.definition.comment.begin | punctuation.definition.comment.end)"
        }
    ]
}

示例，Bash、R、Ruby 和类似语言

{
    "wrap_as_you_type_sections": [
        {
            "combining_selector":
                "source - (comment | constant | entity | invalid | keyword | punctuation | storage | string | variable)",
            "line_start": "#",
            "selector": "comment.line"
        }
    ]
}

示例，C#

{
    "wrap_as_you_type_sections": [
        {
            "allowed_line_starts": ["* ", "*\t"],
            "selector":
                "comment.block - (comment.block.documentation | punctuation.definition.comment.begin | punctuation.definition.comment.end)"
        },
        {
            "combining_selector":
                "source - (comment | constant | entity | invalid | keyword | punctuation | storage | string | variable)",
            "line_start": "///",
            "selector":
                "comment.line.documentation | comment.block.documentation"
        },
        {
            "combining_selector":
                "source - (comment | constant | entity | invalid | keyword | punctuation | storage | string | variable)",
            "line_start": "//",
            "selector": "comment.line - comment.line.documentation"
        }
    ]
}

示例，Perl

{
    "wrap_as_you_type_sections": [
        {
            "selector":
                "comment.block - entity.name.tag - punctuation.definition.comment"
        },
        {
            "combining_selector":
                "source - (comment | constant | entity | invalid | keyword | punctuation | storage | string | variable)",
            "line_start": "#",
            "selector": "comment.line"
        }
    ]
}

补充说明

如果你的最爱语法没有在上面列出，并且你想换行注释，那么参照类似语法的示例进行修改以适应你的语法 shouldn't be too difficult.

在类似 C++ 的语言中，如果你不喜欢以星号开始块注释的每一行，那么请从适当的示例中删除 "allowed_line_starts": ["* ", "*\t"],。你还应该添加以下设置

{
    "wrap_as_you_type_paragraphs": [
        {
            "first_line_regex": "^\\*$",
            "single_line": true
        }
    ]
}

有些人喜欢在编写文本注释时在单行注释标点符号后放置一个空格，在注释代码时不放置空格。例如

// This is a text comment
void foo(bool condition) {
    // This is also a text comment, but the below comments are code comments
    //if (condition) {
    //    bar1();
    //} else {
    //    bar2();
    //    bar3();
    //}
    bar4();
}

在这种情况下，您可以通过将适当的 "line_start" 项从 "//" 更改为 "// "（或将 "#" 更改为 "# " 等）来受益。这会导致 WrapAsYouType 不在非缩进代码注释内部执行单词换行。但是请注意，WrapAsYouType 会将缩进代码注释识别为可换行的文本。在示例中，如果有机会，它将 bar3(); 移动到与 bar2(); 相同的行。这可以被视为 WrapAsYouType 的一个限制。

"wrap_as_you_type_word_regex"

"wrap_as_you_type_word_regex" 是一个用于确定单词位置的 Python 正则表达式，即 WrapAsYouType 可以在此处插入行中断的位置。当与不含前导或尾随空格的非空字符串匹配时，它识别该文本行中的所有单词。我们通过从行首到行尾扫描一行文本，寻找匹配项，获取一个非重叠单词列表。《code>"wrap_as_you_type_word_regex" 默认为 "[\\S\xa0]+"，其中“单词”被定义为非空白字符（以及非换行空格）的序列。

"wrap_as_you_type_word_regex" 可能匹配包含空格的字符串。这可以防止 WrapAsYouType 在该字符串内部的空间处分割该字符串。

示例

{
    "wrap_as_you_type_word_regex": "[^\\s\\{]+|\\{[^\\}]*\\}?"
}

上面的示例强制 WrapAsYouType 将出现在 { 和 } 之间的所有文本作为一个单独的单词保留。不清楚为什么你想这么做，但这只是一个例子。

"wrap_as_you_type_word_regex" 还可能匹配两个没有空格的空间单词。联合使用 "wrap_as_you_type_space_between_words" 设置，这可以用来指示可选的“单词”中途换行点。

示例

{
    "wrap_as_you_type_space_between_words": [
        {
            "first_word_regex": "[^\\-]-+$",
            "space": ""
        }
    ],
    "wrap_as_you_type_word_regex": "[^\\s\\-]+-*|-+[^\\s\\-]*-*"
}

上面的示例允许 WrapAsYouType 在连字符后直接分割单词。例如，WrapAsYouType 允许打破“cookie-cutter”，使“cookie-”出现在一行末尾，“cutter”出现在下一行星首。

"wrap_as_you_type_word_regex" 不允许产生长度为零的单词，或留下任何非空白字符未匹配（不是单词的一部分）。任何允许此操作的正则表达式都作为无效的 "wrap_as_you_type_word_regex" 设置。

"wrap_as_you_type_space_between_words"

"wrap_as_you_type_space_between_words" 设置允许用户指定单词之间的间距。

示例

{
    "wrap_as_you_type_space_between_words": [
        {
            "first_word_regex": "^(?!e\\.g\\.|i\\.e\\.).*[.?!]$",
            "space": "  "
        }
    ]
}

上面的示例会导致 WrapAsYouType 在每个以句号、问号或感叹号结尾的单词后放置两个空格，不包括缩写“e.g.”和“i.e.”。

"wrap_as_you_type_space_between_words" 是一个对象数组。每个对象都有以下项

• "first_word_regex"（可选）：用于对之前空格的单词进行匹配的 Python 正则表达式。
• "second_word_regex"（可选）：用于对之后空格的单词进行匹配的 Python 正则表达式。
• "space"：如果有匹配项，则在单词之间使用的空格。这必须只包含空白字符。

如果 "first_word_regex" 模式与之前空格的单词中的任何部分匹配，或者 "first_word_regex" 项不存在，那么之前空格的单词匹配。同样适用于 "second_word_regex" 和之后空格的单词。如果两个空格的单词都匹配，则使用 "space" 条目作为两个单词之间的间距。请注意，如果多个 "wrap_as_you_type_space_between_words" 的元素匹配给定的单词对，我们使用第一个匹配的元素。如果没有元素匹配，则默认为 " "。

"space" 条目可以是空字符串 ”“，在这种情况下，单词之间不添加空格。结合使用 "wrap_as_you_type_word_regex" 设置，这可以用来指示可选的“单词”中途换行点。

示例

{
    "wrap_as_you_type_space_between_words": [
        {
            "first_word_regex": "[^\\-]-+$",
            "space": ""
        }
    ],
    "wrap_as_you_type_word_regex": "[^\\s\\-]+-*|-+[^\\s\\-]*-*"
}

上面的示例允许 WrapAsYouType 在连字符后直接分割单词。例如，WrapAsYouType 允许打破“cookie-cutter”，使“cookie-”出现在一行末尾，“cutter”出现在下一行星首。

"wrap_as_you_type_paragraphs"

"wrap_as_you_type_paragraphs" 设置提供了一种方法来识别段落分隔符，在这些情况下无法根据缩进来确定。一种可能的用例是以下示例中的 Javadoc 标记标签

public class Sqrt {
    /**
     * Computes a square root.
     * @param value The value to compute the square root of.  This must be at
     *        least 0.
     * @return The square root of "value".
     */
    public static double sqrt(double value) {
        ...
    }
}

在这个例子中，注释块包含三个段落：一个以"Computes"开头，一个以"@param"开头，还有一个以"@return"开头。所有以@符号开头的行都将开始一个新的段落。我们可以使用"wrap_as_you_type_paragraphs"设置来让WrapAsYouType遵守这个规则，如下所示。

{
    "wrap_as_you_type_paragraphs": [
        {
            "first_line_regex": "^@([a-zA-Z]+(\\s+|$)|$)",
            "indent_group": 0
        }
    ]
}

"wrap_as_you_type_paragraphs"是一个对象数组。每个对象都有以下条目：

• "first_line_regex"：一个Python正则表达式，用于将一行文本与模式匹配。如果在给定行文本的任何地方匹配到该模式，则WrapAsYouType将该行视为段落的起始行。某行“文本”是在移除段落行起始部分，然后去除任何前导和尾部空白后得到的。注意，如果一行没有任何文本，那么它永远不会被视为段落的任何部分。
• "indent_levels"（可选）：在第一行之后，段落中每行的缩进级别，相对于第一行的缩进。一个级别等于一个制表符宽度的空格数。默认情况下，没有缩进。
• "indent"（可选）：第一行之后段落中每行的缩进量，相对于第一行的缩进。这必须全部由空白字符组成。同时包含一个"indent"条目和一个"indent_levels"条目是错误的。
• "indent_group"（可选）：用于确定第一行之后段落中每行缩进的正则表达式组。这可以是组号或组名。如果"indent_group"条目存在，并且该组是作为最早的"first_line_regex"匹配的一部分存在的，那么缩进字符串与组字符串相同，但每个不是制表符的字符都被替换为空格。如果"indent_group"条目存在，并且还存在一个"indent"或"indent_levels"条目，则"indent_group"条目占主导地位。
• "single_line"（可选）：段落是否只包含一行：与"first_line_regex"匹配的行。默认值为false。WrapAsYouType不会包装超出包装宽度的单个行段落。如果"single_line"为true，则"indent_levels"、"indent"和"indent_group"条目可能不存在。

上面的例子使用一个"indent_group"条目来指定段落的行在第一行之后的缩进。"indent_group"是0。这指的是包含整个匹配的组，即Javadoc标签及其后面的空格。缩进与匹配的长度相同。因此，在Javadoc标签之后的行与标签后的单词对齐。

如果一行的文本与多个元素的"first_line_regex"模式匹配，则首先匹配的项目占主导地位。

示例，动态类型DocBlocks

{
    "wrap_as_you_type_paragraphs": [
        {
            "first_line_regex":
                "^@(arg|argument|prop|property|param(\\[(in|out|in,out)\\])?)\\s+([^\\{\\s]\\S*|\\{[^\\}]*\\})\\s+([^\\[\\s]\\S*|\\[[^\\]]*\\])\\s+",
            "indent_group": 0
        },
        {
            "first_line_regex":
                "^@(exception|result|returns?|throws?)\\s+([^\\{\\s]\\S*|\\{[^\\}]*\\})\\s+",
            "indent_group": 0
        },
        {
            "first_line_regex":
                "^@(defgroup|link|retval|section|see|snippet|snippetdoc|snippetlineno|source|subsection)\\s+\\S+\\s+",
            "indent_group": 0
        },
        {
            "first_line_regex": "^@([a-zA-Z][a-zA-Z\\[,\\]]*(\\s+|$)|$)",
            "indent_group": 0
        }
    ]
}

上述设置配置WrapAsYouType以识别各种DocBlock格式，例如JSDoc。但它只适用于数据类型作为@param和@return标签的一部分，并且变量名称作为@param标签的一部分进行指定的格式。

DocBlock标签之后的行将缩进，以便与标签的文本描述对齐，如下面的JavaScript代码所示：

/**
 * Computes a square root.
 * @param  {number} value The value to compute the square root of.  This must be
 *                        at least 0.
 * @return {number}       The square root of "value".  The square root is the
 *                        nonnegative number "s" for which s * s is equal to
 *                        "value".
 */
function sqrt(value) {
    ...
}

如果希望不同的缩进级别，可以调整设置以适应您的需求。

示例，静态类型DocBlocks

{
    "wrap_as_you_type_paragraphs": [
        {
            "first_line_regex":
                "^@(serialField|param(\\[(in|out|in,out)\\])?)\\s+([^\\[\\s]\\S*|\\[[^\\]]*\\])\\s+",
            "indent_group": 0
        },
        {
            "first_line_regex":
                "^@(exception|throws?)\\s+([^\\{\\s]\\S*|\\{[^\\}]*\\})\\s+",
            "indent_group": 0
        },
        {
            "first_line_regex":
                "^@(defgroup|retval|section|see|snippet|snippetdoc|snippetlineno|subsection|tparam)\\s+\\S+\\s+",
            "indent_group": 0
        },
        {
            "first_line_regex": "^@([a-zA-Z][a-zA-Z\\[,\\]]*(\\s+|$)|$)",
            "indent_group": 0
        }
    ]
}

此设置配置 WrapAsYouType 以识别 DocBlock 格式，例如 Javadoc 格式，在这种格式中，数据类型不由 @param 和 @return 标签的一部分指定，并且变量名由 @param 标签的一部分指定。

示例，Google 风格的 Python 文档字符串

{
    "wrap_as_you_type_paragraphs": [
        {
            "first_line_regex": "^(\\*?\\*?[a-zA-Z_][a-zA-Z_0-9]*|[a-zA-Z_][a-zA-Z_0-9]*\\[.+\\]|[a-zA-Z_][a-zA-Z_0-9]* \\([^\\)]+\\)): ",
            "indent_levels": 1
        },
        {
            "first_line_regex": "^((>>>|\\.\\.\\.)( |$)|<BLANKLINE>$)",
            "single_line": true
        },
        {
            "first_line_regex": "^(\"\"?|''?)$",
            "single_line": true
        }
    ]
}

"wrap_as_you_type_enter_extends_section"

如果将 "wrap_as_you_type_enter_extends_section" 设置为 true，按下回车键将插入一行，并加入当前节的部分开头。这在扩展块注释或一系列行注释时非常有用。您仍然可以使用 Shift+Enter 来获得默认的换行行为。

更精确地说，如果选择光标位于一个可以折叠的节中，并且该节延伸到行的开头，则按回车键将插入换行符，随后是节的行起始字符串，以及适当的缩进。

"wrap_as_you_type_passive"

如果将 "wrap_as_you_type_passive" 设置为 true，WrapAsYouType 对所做更改的限制较少。特别是，它不会尝试将单词从当前行的开头移动到上一行的末尾。

一种使用情况是在编辑诸如 DocBlock 之类的结构化注释时。通常，WrapAsYouType 可以通过使用 "wrap_as_you_type_paragraphs" 设置来指示尊重此类注释的格式。但是，如果一个用户无法或不愿意为 "wrap_as_you_type_paragraphs" 配置以识别注释所使用的格式，他可能更喜欢将 "wrap_as_you_type_passive" 设置为 true。

"wrap_as_you_type_disabled"

"wrap_as_you_type_disabled" 是一个布尔值，指示 WrapAsYouType 插件是否停止运行。当前选项卡中的 "toggle_wrap_as_you_type" 命令反转 "wrap_as_you_type_disabled"。

您可能会发现在某些情况下，WrapAsYouType 会阻挡您正在尝试输入的内容。也许您正在使用 ASCII 艺术创作图表，或者也许您的注释中包含代码示例。在这些情况下，建议您使用 "toggle_wrap_as_you_type" 命令临时禁用 WrapAsYouType。您可以通过转到“首选项”>“密钥绑定”菜单项将命令绑定到密钥组合。

示例

[
    {
        "command": "toggle_wrap_as_you_type",
        "keys": ["super+alt+w"]
    }
]

如果您想永久禁用 WrapAsYouType，请考虑卸载它或将它添加到 "ignored_packages" 设置中。

示例

{
    "ignored_packages": ["WrapAsYouType"]
}

与自动（硬）换行的比较

WrapAsYouType 与 自动（硬）换行 插件相似，因为它们都会在用户打字时自动进行硬单词换行。然而，WrapAsYouType 相比于自动（硬）换行有很多优点。

WrapAsYouType 相比于自动（硬）换行的优点

• 自动（硬）换行不会重新排列整个段落。例如，在正确流动的段落的中间增加一点文本会导致几乎满行的行，然后是几乎空行的行，然后是几乎满行的行。
• 自动（硬）换行会缩进所有文本，而不仅仅是注释。相比之下，WrapAsYouType 为用户提供选项，可以仅缩进注释，甚至可以配置要缩进的节。
• 自动（硬）换行不总是尊重缩进。
• 自动（硬）换行不支持自定义行开头，例如在 C++ 块注释的每行开始使用 " * "。

自动（硬）换行相比 WrapAsYouType 的优点

• WrapAsYouType 需要用户为每种编程语言提供特殊设置。