##tex 和 latex

###1. TeX：底层排版引擎

• 作者：Donald Knuth（高德纳）开发，1978 年发布。
• 定位：
  • 是一个底层的排版编程语言，提供精确的排版控制（如盒模型、断行算法、数学公式布局等）。
  • 语法类似编程（需手动处理格式细节），适合专业人士或极客。
• 特点：
  • 直接操作命令（如 \hbox, \vskip）。
  • 默认生成 .dvi 文件（需转换为 PDF/PS）。
  • 无预定义的高层结构（如章节、目录需手动实现）。

示例（纯 TeX 代码）：

\font\myfont=cmr12 at 14pt
\myfont Hello, \TeX!
\byecopy

###2. LaTeX：基于 TeX 的高级封装

• 作者：Leslie Lamport（莱斯利·兰波特）开发，1984 年发布。
• 定位：
  • 是 TeX 的宏包集合（一组预定义的命令和模板），提供文档逻辑结构（如章节、参考文献、交叉引用）。
  • 隐藏了 TeX 的底层复杂性，用户只需关注内容。
• 特点：
  • 提供标准文档类（如 article, book）。
  • 内置自动化功能（目录、编号、参考文献管理）。
  • 依赖宏包扩展功能（如 graphicx 插入图片、amsmath 增强数学公式）。

示例（LaTeX 代码）：

\documentclass{article}
\begin{document}
\section{Introduction}
Hello, \LaTeX!
\end{document}copy

###核心区别

###类比解释

• TeX 类似汇编语言：
  • 直接控制硬件（排版细节），但编写复杂。
• LaTeX 类似高级语言（如 Python）：
  • 通过抽象（如 \section）隐藏细节，提升效率。

###技术关系

• LaTeX 本质是一组 TeX 宏（.sty 文件），最终仍由 TeX 引擎（如 pdftex, xetex, luatex）执行。
• 编译流程示例：
  sh

  latex document.tex   # 调用 pdftex 引擎处理 LaTeX 宏
  xelatex document.tex # 调用 xetex 引擎处理 LaTeX 宏copy

###总结

• TeX 是引擎，LaTeX 是模板。
• LaTeX 让用户摆脱 TeX 的底层复杂性，专注于内容逻辑。
• 现代用户通常直接使用 pdflatex/xelatex/lualatex，无需接触原始 TeX 命令。

如果需要进一步解释某个具体细节（如宏包机制或引擎差异），可以继续讨论！

##引擎和使用

###1. 排版引擎（Engines）

引擎是实际执行排版工作的底层程序，负责解析代码、计算布局并生成输出文件（如 PDF/DVI）。
属于引擎的有：

• tex：Knuth 原始 TeX 引擎（生成 .dvi）。
• pdftex：扩展的 TeX 引擎，直接生成 PDF（pdflatex 的基础）。
• xetex（XeTeX）：支持 Unicode 和系统字体的引擎（xelatex 的基础）。
• luatex（LuaTeX）：内嵌 Lua 脚本的引擎（lualatex 的基础）。

###2. 模板/格式（Formats）

格式是基于引擎的预定义命令集合（宏包），提供高层抽象，简化用户操作。
属于格式的有：

• latex：LaTeX 格式（运行在 pdftex/xetex/luatex 等引擎上）。
  • 不是独立引擎，而是通过 latex 命令调用引擎（如 pdftex + LaTeX 宏 → pdflatex）。
• plain tex：Knuth 提供的极简格式（比原始 TeX 稍友好，但远不如 LaTeX）。
• contex：另一种高级格式（基于 LuaTeX，适合复杂排版）。

###3. 前端命令（Frontends）

用户直接调用的命令，本质是 “引擎 + 格式” 的组合：

###关键区分

• 引擎：tex, pdftex, xetex, luatex（核心执行者）。
• 格式：latex, plain tex, contex（定义高级命令的规则）。
• 前端命令：latex, pdflatex, xelatex, lualatex（组合引擎和格式的快捷方式）。

###常见误解澄清

1. latex 不是引擎：
   • 它是 LaTeX 格式通过 pdftex 引擎运行的接口（命令）。
2. pdflatex vs pdftex：
   • pdftex 是引擎，pdflatex = pdftex + LaTeX 格式。

##引擎（Engines）

###基础引擎

###引擎特性对比

##格式（Formats）

###主要格式

##前端命令（Frontend Commands）

###常用命令组合

##文件格式

###输入文件类型

###输出文件类型

##工具链组件

###核心工具

###编译工具链

graph TD
    A[.tex源文件] --> B{选择引擎}
    B --> C[pdflatex]
    B --> D[xelatex]
    B --> E[lualatex]

    C --> F[生成PDF]
    D --> F
    E --> F

    subgraph "可选处理"
        G[.bib文件] --> H[bibtex]
        I[.idx文件] --> J[makeindex]
        H --> K[.bbl文件]
        J --> L[.ind文件]
    end

    K --> C
    L --> C

##选择指南

###引擎选择建议

1. 中文/多语言文档：xelatex 或 lualatex
2. 传统英文文档：pdflatex
3. 需要动态功能：lualatex（Lua脚本）
4. 底层开发：tex 或 luatex

##列举

###1. tex（原始 TeX 引擎）

• 作用：Knuth 开发的原始 TeX 排版引擎，处理 .tex 文件并生成 .dvi（DeVice Independent）文件。
• 特点：
  • 仅支持传统的 TeX 命令，不支持现代字体（如 OpenType）。
  • 主要用于历史兼容性或极简排版。
• 使用示例：
  sh

  tex mydocument.tex  # 生成 mydocument.dvicopy

###2. latex（LaTeX 格式 + pdfTeX 引擎）

• 作用：使用 pdftex 引擎处理 LaTeX 文档（.tex），默认生成 PDF（也可生成 DVI）。
• 特点：
  • 基于 pdftex，支持 PDF 输出、微调排版和基本字体扩展。
  • 但不支持 Unicode 和 OpenType 字体（需额外宏包如 fontspec）。
• 使用示例：
  sh

  latex mydocument.tex  # 生成 mydocument.dvi
  pdflatex mydocument.tex  # 生成 mydocument.pdfcopy

###3. xetex（XeTeX 引擎，支持 Unicode 和系统字体）

• 作用：TeX 引擎，原生支持 Unicode 和系统字体（如 .ttf/.otf）。
• 特点：
  • 直接调用系统字体，无需额外配置。
  • 适用于多语言排版（如中文、阿拉伯语）。
  • 输出格式为 .xdv（扩展 DVI），通常转换为 PDF。
• 使用示例：
  sh

  xetex mydocument.tex  # 生成 mydocument.xdv（通常自动转 PDF）copy

###4. xelatex（LaTeX + XeTeX 引擎）

• 作用：latex 的增强版，使用 xetex 引擎处理 LaTeX 文档，支持现代字体。
• 特点：
  • 支持 fontspec 宏包，可轻松使用系统字体。
  • 适合中文排版（如配合 ctex 宏包）。
• 使用示例：
  sh

  xelatex mydocument.tex  # 直接生成 PDFcopy

###5. luatex（LuaTeX 引擎，支持 Lua 脚本）

• 作用：扩展的 TeX 引擎，内置 Lua 解释器，允许动态脚本控制排版。
• 特点：
  • 支持 Unicode 和 OpenType 字体（类似 XeTeX）。
  • 可通过 \directlua{} 嵌入 Lua 代码，实现高级自动化。
  • 默认生成 PDF。
• 使用示例：
  sh

  luatex mydocument.tex  # 生成 PDFcopy

###6. lualatex（LaTeX + LuaTeX 引擎）

• 作用：latex 的现代替代品，使用 luatex 引擎，结合 LaTeX 和 Lua 扩展。
• 特点：
  • 支持 fontspec 和 Lua 脚本，灵活性极高。
  • 适合复杂排版（如自动生成内容、动态调整格式）。
• 使用示例：
  sh

  lualatex mydocument.tex  # 生成 PDFcopy

###总结对比

##cmd

Lua 输出：

:lua =vim.opt.runtimepath:get()copy

:setl ma! ma? 可以切换一个buffer的只读状态。 注意其他编辑器的只读一般是“你可以修改但不能保存“，这个是你根本不能修改，比如说根本就不能进入插入模式。 可以设一个顺手的keymap，比如说我是nnoremap ;m :setl ma! ma? 。

另外，:setl xxx! xxx? 这个是一个常用切换option开关的模式，比如说:nnoremap w setl wrap! wrap?设keymap来切换自动换行，并在状态栏显示当前实际状态。

xnoremap ,x <ESC>`.`gvp`P
abbrev ,f <C-R>=expand("%:")<left><left>
abbrev ,c <C-R>=getcwd()<cr>copy

下面的keymap可以直接执行一行vimscript或者lua （取决于当前文件类型）。用来调整或者测试vim配置非常方便，改完一行就执行一下，不需要source整个vimrc文件了。

command! -range ExecVimL call execute(getline(<line1>, <line2>), '')
command! -range ExecLua call execute('lua ' . join(getline(<line1>, <line2>), " \n "), '')
nnoremap <silent> <expr> ,r ((&ft=='lua' ? ':ExecLua' : ':ExecVimL') . '<cr>:<c-u>echo "Current line executed"<cr>')
xnoremap <silent> <expr> ,r ((&ft=='lua' ? ':ExecLua' : ':ExecVimL') . '<cr>:<c-u>echo "Selected range executed"<cr>')copy

链接：https://www.zhihu.com/question/636018229/answer/3386613023 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

用.!（当前行），%!（整个buff），'<,'>! (选中）可以把文本作为stdin传给一个外部shell命令，并用其stdout输出内容替换相应文本，用来调外部的格式化命令很方便。另外，如果传给bash或zsh的话就相当于把文本作为shell命令执行。

「修改 1」→「撤销」→「修改 2」，这时如果想退回到「修改 1」，按 u 是回不去的。

可以按 g-（反方向是 g+）

实际上等同于 :earlier 和 :later 。这两个命令后边是可以跟「次数」而不是「时间」的顺便一说，不写默认是 1 次。

test 2

##start up of nvim

##lazy.nvim

lazy.nvim 配置的表合并情况。例如假设treesitter的默认配置为

return {
  "nvim-treesitter/nvim-treesitter",
  opts = {
    ensure_installed = { "lua", "vim" },
    highlight = {
      enable = true,
    },
  },
}copy

手动配置

return {
  "nvim-treesitter/nvim-treesitter",
  opts = {
    ensure_installed = { "python" },
    highlight = {
      enable = false,
    },
    indent = {
      enable = false,
    },
  },
}copy

那么最后会得到ensure_installed = { "python" }。如何要拓展表，则要用

table.insert(opts.ensure_installed, "python")copy

##help

A time tracking tool used to measure the duration of activities. .

  Start tracking an activity:

      timew start

  Tag the current activity:

      timew tag activity_tag

  Start tracking and tag a new activity:

      timew start activity_tag

  Stop the current activity:

      timew stop

  Track an activity in the past:

      timew track start_time - end_time activity_tag

  View tracked items of the day:

      timew summary

  View report for the last day, week, current month, etc.:

      timew summary :today|yesterday|week|lastweek|month|lastmonth|year|lastyearcopy

Usage: timew [--version]
       timew annotate @<id> [@<id> ...] <annotation>
       timew cancel
       timew config [<name> [<value> | '']]
       timew continue [@<id>] [<date>|<interval>]
       timew day [<interval>] [<tag> ...]
       timew delete @<id> [@<id> ...]
       timew diagnostics
       timew export [<interval>] [<tag> ...]
       timew extensions
       timew gaps [<interval>] [<tag> ...]
       timew get <DOM> [<DOM> ...]
       timew help [<command> | dates | dom | durations | hints | ranges]
       timew join @<id> @<id>
       timew lengthen @<id> [@<id> ...] <duration>
       timew modify (start|end) @<id> <date>
       timew modify range @<id> <interval>
       timew month [<interval>] [<tag> ...]
       timew move @<id> <date>
       timew [report] <report> [<interval>] [<tag> ...]
       timew retag @<id> [@<id> ...] <tag> [<tag> ...]
       timew shorten @<id> [@<id> ...] <duration>
       timew show
       timew split @<id> [@<id> ...]
       timew start [<date>] [<tag> ...]
       timew stop [<tag> ...]
       timew summary [<interval>] [<tag> ...]
       timew tag @<id> [@<id> ...] <tag> [<tag> ...]
       timew tags [<interval>] [<tag> ...]
       timew track <interval> [<tag> ...]
       timew undo
       timew untag @<id> [@<id> ...] <tag> [<tag> ...]
       timew week [<interval>] [<tag> ...]

Additional help:
       timew help <command>
       timew help dates
       timew help dom
       timew help durations
       timew help hints
       timew help ranges

Interval:
       [from] <date>
       [from] <date> to/- <date>
       [from] <date> for <duration>
       <duration> before/after <date>
       <duration> ago
       [for] <duration>

Tag:
       Word
       'Single Quoted Words'
       "Double Quoted Words"
       Escaped\ Spaces

Configuration overrides:
       rc.<name>=<value>copy

##timew-dom - Timewarrior DOM

Supported DOM references are:

dom.tag.count             Count of all tags
dom.tag.1                 Nth tag usedcopy

dom.active                '1' if there is active tracking, otherwise '0'
dom.active.tag.count      Count of active tags
dom.active.tag.1          Active Nth tag
dom.active.start          Active start timestamp (ISO Extended local date)
dom.active.duration       Active elapsed (ISO Period)
dom.active.json           Active interval as JSONcopy

dom.tracked.count         Count of tracked intervals
dom.tracked.1.tag.count   Count of active tags
dom.tracked.1.tag.1       Tracked Nth, Nth tag
dom.tracked.1.start       Tracked Nth, start time
dom.tracked.1.end         Tracked Nth, end time, blank if closed
dom.tracked.1.duration    Tracked Nth, elapsed
dom.tracked.1.json        Tracked Nth, interval as JSONcopy

dom.rc.<name>             Configuration settingcopy

Command-line to-do list manager. .

##overview

Taskwarrior has a flexible command line syntax, but it may not be clear at first what the underlying structure means. Here is the general form of the syntax:

There are four parts to the syntax (filter, command, modifications, and miscellaneous), and each part is optional.

  Add a new task which is due tomorrow:
      task add description due:tomorrow

  Update a task's priority:

      task task_id modify priority:H|M|L

  Complete a task:

      task task_id done

  Delete a task:

      task task_id delete

  List all open tasks:

      task list

  List open tasks due before the end of the week:

      task list due.before:eow

  Show a graphical burndown chart, by day:

      task burndown.daily

  List all reports:

      task reportscopy

man:

Documentation for Taskwarrior can be found using 'man task', 'man taskrc', 'man task-color', 'man task-sync' or at https://taskwarrior.org

The general form of commands is:
  task [<filter>] <command> [<mods>]


The <mods> consist of zero or more changes to apply to the selected tasks, such as:
  task <filter> <command> project:Home
  task <filter> <command> +weekend +garden due:tomorrow
  task <filter> <command> Description/annotation text
  task <filter> <command> /from/to/     <- replace first match
  task <filter> <command> /from/to/g    <- replace all matches

Tags are arbitrary words, any quantity:
  +tag       The + means add the tag
  -tag       The - means remove the tag

Built-in attributes are:
  description:    Task description text
  status:         Status of task - pending, completed, deleted, waiting
  project:        Project name
  priority:       Priority
  due:            Due date
  recur:          Recurrence frequency
  until:          Expiration date of a task
  limit:          Desired number of rows in report, or 'page'
  wait:           Date until task becomes pending
  entry:          Date task was created
  end:            Date task was completed/deleted
  start:          Date task was started
  scheduled:      Date task is scheduled to start
  modified:       Date task was last modified
  depends:        Other tasks that this task depends upon
Alternately algebraic expressions support:
  and  or  xor            Logical operators
  <  <=  =  !=  >=  >     Relational operators
  (  )                    Precedence

  task due.before:eom priority.not:L   list
  task '(due < eom and priority != L)'  listcopy

###Filter

A filter is a means of addressing a subset of tasks. Because filters are optional, the simplest case is no filter. A command with no filter addresses all tasks.

Generally filter arguments appear before the command, so any arguments to the left of the command are considered filter arguments.

There is a special case, in which a command that does not support modifications or miscellaneous arguments, expects only filter arguments, and so they can appear before or after the command, without confusing Taskwarrior:

###Command

Each time you run Taskwarrior, you are issuing a command either explicitly, or implicitly with the default command (the default.command configuration setting). The command you specify determines how the command line is understood by Taskwarrior. Here are some examples of that:

The first example, task list is a report with no filter, and the second, task +home list is with a filter. The third, task 12 modify project:Garden has both a filter and modifications. The last example, task show editor has a miscellaneous argument.

Taskwarrior looks for the first argument on the command line that looks like an exact command name, and failing that, looks for an abbreviated command name. It is better to use the full name of a command to avoid ambiguity.

It is the position of the command argument, and the type of command that determines how the arguments are understood.

task的列信息

Command          Category  R/W ID GC Recur Context Filter Mods Misc Description
columns          config     RO                                 Misc All supported columns and formatting styles
config           config     RO                                 Misc Change settings in the task configuration
reports          config     RO                                      Lists all supported reports
show             config     RO                                 Misc Shows all configuration variables or subset
udas             config     RO                                      Shows all the defined UDA details
commands         metadata   RO                                      Generates a list of all commands, with behavior details
stats            metadata   RO    GC          Ctxt   Filt           Shows task database statistics
ids              metadata   RO ID GC Recur           Filt           Shows the IDs of matching tasks, as a range
count            metadata   RO    GC Recur    Ctxt   Filt           Counts matching tasks
projects         metadata   RO    GC Recur    Ctxt   Filt           Shows all project names used
tags             metadata   RO    GC          Ctxt   Filt           Shows a list of all tags used
uuids            metadata   RO    GC Recur           Filt           Shows the UUIDs of matching tasks, as a space-separated list
context          context    RO                                 Misc Set and define contexts (default filters / modifications)copy

获取信息

_aliases         internal   RO                                      Generates a list of all aliases, for autocompletion purposes
_columns         internal   RO                                      Displays only a list of supported columns
_commands        internal   RO                                      Generates a list of all commands, for autocompletion purposes
_config          internal   RO                                      Lists all supported configuration variables, for completion purposes
_context         internal   RO                                      Lists all supported contexts, for completion purposes
_get             internal   RO                                 Misc DOM Accessor
_ids             internal   RO ID GC Recur           Filt           Shows the IDs of matching tasks, in the form of a list
_projects        internal   RO    GC Recur           Filt           Shows only a list of all project names used
_show            internal   RO    GC                                Shows all configuration settings in a machine-readable format
_tags            internal   RO    GC Recur           Filt           Shows only a list of all tags used, for autocompletion purposes
_udas            internal   RO                                      Shows the defined UDAs for completion purposes
_unique          internal   RO ID GC                 Filt      Misc Generates lists of unique attribute values
_urgency         internal   RO    GC                 Filt           Displays the urgency measure of a task
_uuids           internal   RO    GC Recur           Filt           Shows the UUIDs of matching tasks, as a list
_version         internal   RO                                      Shows only the Taskwarrior version number
_zshattributes   internal   RO                                      Generates a list of all attributes, for zsh autocompletion purposes
_zshcommands     internal   RO                                      Generates a list of all commands, for zsh autocompletion purposes
_zshids          internal   RO ID GC Recur           Filt           Shows the IDs and descriptions of matching tasks
_zshuuids        internal   RO    GC Recur           Filt           Shows the UUIDs and descriptions of matching taskscopy

操作

add              operation  RW                Ctxt        Mods      Adds a new task
annotate         operation  RW                       Filt Mods      Adds an
append           operation  RW                       Filt Mods      Appends text to
delete           operation  RW                Ctxt   Filt Mods      Deletes the
denotate         operation  RW                Ctxt   Filt      Misc Deletes an
done             operation  RW                Ctxt   Filt Mods      Marks the
duplicate        operation  RW                Ctxt   Filt Mods      Duplicates the
edit             operation  RW       Recur    Ctxt   Filt           Launches an
log              operation  RW                Ctxt        Mods      Adds a new task
modify           operation  RW                       Filt Mods      Modifies the
prepend          operation  RW                Ctxt   Filt Mods      Prepends text to
purge            operation  RW    GC          Ctxt   Filt           Removes the
start            operation  RW                Ctxt   Filt Mods      Marks specified
stop             operation  RW                Ctxt   Filt Mods      Removes the
undo             operation  RW                                      Reverts the mostcopy

统计

burndown.daily   graphs     RO    GC Recur    Ctxt   Filt           Shows a
burndown.monthly graphs     RO    GC Recur    Ctxt   Filt           Shows a
burndown.weekly  graphs     RO    GC Recur    Ctxt   Filt           Shows a
calendar         graphs     RO ID GC                           Misc Shows a
ghistory.annual  graphs     RO       Recur    Ctxt   Filt           Shows a
ghistory.daily   graphs     RO       Recur    Ctxt   Filt           Shows a
ghistory.monthly graphs     RO       Recur    Ctxt   Filt           Shows a
ghistory.weekly  graphs     RO       Recur    Ctxt   Filt           Shows a
history.annual   graphs     RO       Recur    Ctxt   Filt           Shows a report
history.daily    graphs     RO       Recur    Ctxt   Filt           Shows a report
history.monthly  graphs     RO       Recur    Ctxt   Filt           Shows a report
history.weekly   graphs     RO       Recur    Ctxt   Filt           Shows a report
summary          graphs     RO    GC          Ctxt   Filt           Shows a reportcopy

###Modifications

If a command accepts modifications, they generally appear after the command. Most commands that accept modifications also accept filters, and so the filter arguments appear before the command, while the modifications appear after. Here is an example:

This command specifies a compound filter, consisting of more than one term. These terms are logically combined with an and operator by default, unless otherwise specified. In this case, tasks that have both the home tag, and a status value of pending are to be modified.

The modifications, appearing after the command, set the priority to H igh, and the due date to the end of the month (eom).

Because the filter is evaluated at runtime, we don’t know how many tasks will be modified. It could be none, one, many or all of the tasks. It could be determined with:

task +home status:pending countcopy

The user writing this command would have an idea of how many tasks this will affect, but this is just an example, with no contextual data shown.

###Miscellaneous

Some commands accept neither a filter, nor modifications, but do accept miscellaneous arguments. An example is the show command, that queries configuration settings, and does not accept a filter:

This is another special case, in which the command only accepts miscellaneous arguments, and so they can appear before or after the command.

###Overrides

Overrides are temporary values for configuration settings, and can be specified anywhere on the command line, because they are not considered to be either filter, modification or miscellaneous. In fact, the command itself doesn’t see the overrides, instead they are handled before the command runs.

There can be any number of overrides on the command line, and they have no effect on the syntax.

##reports

Taskwarrior has three kinds of reports. There are built-in reports that cannot be modified, such as info and summary. There are built-in reports which can be redefined completely or eliminated, such as list, next. And finally there are your own custom reports. To generate a list of all the reports, use the reports command:

Report           Description
---------------- --------------------------------------------------
active           Active tasks
all              All tasks
blocked          Blocked tasks
blocking         Blocking tasks
burndown.daily   Shows a graphical burndown chart, by day
burndown.monthly Shows a graphical burndown chart, by month
burndown.weekly  Shows a graphical burndown chart, by week
completed        Completed tasks
ghistory.annual  Shows a graphical report of task history, by year
ghistory.monthly Shows a graphical report of task history, by month
history.annual   Shows a report of task history, by year
history.monthly  Shows a report of task history, by month
information      Shows all data and metadata
list             Most details of tasks
long             All details of tasks
ls               Few details of tasks
minimal          Minimal details of tasks
newest           Newest tasks
next             Most urgent tasks
oldest           Oldest tasks
overdue          Overdue tasks
projects         Shows all project names used
ready            Most urgent actionable tasks
recurring        Recurring Tasks
summary          Shows a report of task status by project
tags             Shows a list of all tags used
unblocked        Unblocked tasks
waiting          Waiting (hidden) tasks

28 reportscopy

###Built-In Static Reports

Typically, a report consists of a table of data, with one row of data corresponding to a single task, with the task attributes represented as columns. But there are other reports which do not conform to this structure. Those are the built-in static reports, and they are not modifiable, because they are quirky and require custom code. These reports are:

burndown.daily
burndown.monthly
burndown.weekly
calendar
colors
export
ghistory.annual
ghistory.monthly
history.annual
history.monthly
information
summary
timesheetcopy

Each of these reports takes non-standard arguments, may or may not support filters, and generates distinctive output.

###Built-In Modifiable Reports

These reports are standard format, using standard arguments, and are also modifiable.

active
all
blocked
blocking
completed
list
long
ls
minimal
newest
next
oldest
overdue
ready
recurring
unblocked
waitingcopy

Suppose you wanted to remove a column from one of these reports, for example removing tags from the minimal report. First look at the existing columns and labels of the minimal report:

task show report.minimal.labels shows

Config Variable       Value
--------------------- ---------------------------
report.minimal.labels ID,Project,Tags,Descriptioncopy

and task show report.minimal.columns shows

Config Variable        Value
---------------------- ---------------------------------------
report.minimal.columns id,project,tags.count,description.countcopy

Having determined what the current values are, simply override with the new values:

$ task config report.minimal.labels  'ID,Project,Description'
...
$ task config report.minimal.columns 'id,project,description.count'copy

You can think of the built-in modifiable reports as a set of default custom reports.

###Custom Reports

Defining a custom report is straightforward. You have control over the data shown, the sort order and the column labels. A custom report is simply a set of configuration values, and those values include:

• description
• columns
• labels
• sort
• filter

Let us quickly create a custom report, which will be named simple. This report will display the task ID, project name and description. We will need to gather the five settings listed above.

The description is the easiest, and in this case the report will be described:

Simple list of open tasks by projectcopy

This is just a descriptive label that will be used when the report is listed. Next we need to specify the columns in the report, and the order in which those are shown. Here the _columns helper command will show the columns available:

task _columns shows

depends
description
due
end
entry
foo
id
imask
mask
modified
parent
priority
project
recur
scheduled
start
status
tags
until
urgency
uuid
waitcopy

That represents all the data that Taskwarrior stores, and therefore all the data that may be shown in a report. Our simple report will show id, project and description, which are all in the list. This means our column list is simply:

id,project,descriptioncopy

But there are also formats for each column, and the columns command shows them, with examples. Here are the formats for our three columns: task columns id

Columns Supported Formats Example
------- ----------------- ------------------------------------
id      number*           123
uuid    long*             f30cb9c3-3fc0-483f-bfb2-3bf134f00694
        short             f30cb9c3copy

This is easy, because there is only one id format. task columns project

Columns Supported Formats Example
------- ----------------- -------------
project full*             home.garden
        parent            home
        indented            home.gardencopy

There are three formats for the project column, and the default, full is the one we want. task columns description

Columns     Supported Formats Example
----------- ----------------- -----------------------------------------------------------------------------
description combined*         Move your clothes down on to the lower peg
                                2014-02-08 Immediately before your lunch
                                2014-02-08 If you are playing in the match this afternoon
                                2014-02-08 Before you write your letter home
                                2014-02-08 If you're not getting your hair cut
            desc              Move your clothes down on to the lower peg
            oneline           Move your clothes down on to the lower peg 2014-02-08 Immediately before ...
                              this afternoon 2014-02-08 Before you write your letter home 2014-02-08 If ...
            truncated         Move your clothes do...
            count             Move your clothes down on to the lower peg [4]copy

There are five formats for description. This time we prefer the count format, so our columns list is now:

id,project,description.countcopy

Labels are the column heading labels in the report. There are defaults, but we wish to specify these like this:

ID,Proj,Desccopy

Sorting is also straightforward, and we want the tasks sorted by project, and then by entry, which is the creation date for a task. This illustrates that a task attribute that is not visible can be used in the sort. The sort order is then:

project+/,entry+copy

The + means an ascending order, but we could have used - for descending. The / solidus indicates that project is a break column, which means a blank line is inserted between unique values, for a visual grouping effect. 2.4.0

Finally, we need a filter, otherwise our report will just display all tasks, which is rarely wanted. Here we wish to see only pending tasks, and that means the filter is:

status:pendingcopy

Now we have our report definition, so we just create the five configuration entries like this:

task config report.simple.description 'Simple list of open tasks by project'
task config report.simple.columns     'id,project,description.count'
task config report.simple.labels      'ID,Proj,Desc'
task config report.simple.sort        'project+/,entry+'
task config report.simple.filter      'status:pending'copy

Note the equivalent report directly from the config file would look like that:

report.simple.description=Simple list of open tasks by project
report.simple.columns=id,project,description.count
report.simple.labels=ID,Proj,Desc
report.simple.sort=project+\/,entry+
report.simple.filter=status:pendingcopy

And it is finished. Run the report like this:

task simple

ID Proj Desc
-- ---- -----------------
 1 Home Wash the windows
 3 Home Vacuum the floors

 2      Food shoppingcopy

Custom reports also show up in the help output.

task help | grep simple
task  simple              Simple list of open tasks by projectcopy

I can inspect the configuration.

task show report.simple

Config Variable           Value
------------------------- ------------------------------------
report.simple.columns     id,project,description.count
report.simple.description Simple list of open tasks by project
report.simple.filter      status:pending
report.simple.labels      ID,Proj,Desc
report.simple.sort        project+/,entry+copy

Now the report is fully configured, it joins the others and is used in the same way.

##attributes

###built-in

Built-in attributes are:
  description:    Task description text
  status:         Status of task - pending, completed, deleted, waiting
  project:        Project name
  priority:       Priority
  due:            Due date
  recur:          Recurrence frequency
  until:          Expiration date of a task
  limit:          Desired number of rows in report, or 'page'
  wait:           Date until task becomes pending
  entry:          Date task was created
  end:            Date task was completed/deleted
  start:          Date task was started
  scheduled:      Date task is scheduled to start
  modified:       Date task was last modified
  depends:        Other tasks that this task depends uponcopy

###modifiers

Attribute modifiers make filters more precise. Supported modifiers are:

  Modifiers         Example            Equivalent           Meaning
  ----------------  -----------------  -------------------  -------------------------
                    due:today          due = today          Fuzzy match
  not               due.not:today      due != today         Fuzzy non-match
  before, below     due.before:today   due < today          Exact date comparison
  after, above      due.after:today    due >= tomorrow      Exact date comparison
  none              project.none:      project == ''        Empty
  any               project.any:       project !== ''       Not empty
  is, equals        project.is:x       project == x         Exact match
  isnt              project.isnt:x     project !== x        Exact non-match
  has, contains     desc.has:Hello     desc ~ Hello         Pattern match
  hasnt,            desc.hasnt:Hello   desc !~ Hello        Pattern non-match
  startswith, left  desc.left:Hel      desc ~ '^Hel'        Beginning match
  endswith, right   desc.right:llo     desc ~ 'llo$'        End match
  word              desc.word:Hello    desc ~ '\bHello\b'   Boundaried word match
  noword            desc.noword:Hello  desc !~ '\bHello\b'  Boundaried word non-match

Alternately algebraic expressions support:
  and  or  xor            Logical operators
  <  <=  =  !=  >=  >     Relational operators
  (  )                    Precedence

  task due.before:eom priority.not:L   list
  task '(due < eom and priority != L)'  listcopy

note that

  by         due.by:today       due <= today         Exact date comparisoncopy

###How Recurrence Works

A recurring task is a task with a due date that keeps coming back as a reminder. Here is an example:

task add Pay the rent due:1st recur:monthly until:2015-03-31
Created task 123.copy

This task has a due date, a monthly recurrence, and an optional until date coinciding with the end of the lease.

A recurring task is given a status of recurring which hides it from view, although you can see it in the all report. The recurring task you create is called the template task, from which recurring tasks instances are created. So the template remains hidden, and the recurring instances that spawn from it are the tasks that you will see and complete.

Here is a look at the template task:

task 123 info

Name        Value
ID          123
Description Pay the rent
Status      Recurring
Recurrence  monthly
Entered     2014-03-01 12:13:28 (42 secs)
Due         2014-04-01 00:00:00
Until       2015-03-31 00:00:00
UUID        64bcf8fd-74d5-40d2-9e57-1d6a5922cdfc
Urgency     2.4copy

Now if you run a report, such as task list, you will see the first instance of that recurring task generated. We can take a look at the instance:

task 124 info

Name        Value
ID          124
Description Pay the rent
Status      Pending
Recurrence  monthly
Parent task 64bcf8fd-74d5-40d2-9e57-1d6a5922cdfc
Mask Index  0
Entered     2014-03-01 12:17:03 (15 secs)
Due         2014-04-01 00:00:00
Until       2015-03-31 00:00:00
UUID        29d2df7a-1165-4559-b974-a727519e00f1
Urgency     2.4copy

Notice how the instance has a status pending, and a reference back to the template task (Parent task). In addition, you can see it inherited the recurrence and description, and if there was a project, priority and tags, those would also be inherited.

The recurring instance has an attribute named ‘Mask Index’, which is zero. This indicates that it is the first of the many recurring task instances, the counting being zero-based.

Now if we look back at the template task, we see changes:

task 123 info

Name          Value
ID            123
Description   Pay the rent
Status        Recurring
Recurrence    monthly
Mask          -
Entered       2014-03-01 12:13:28 (3 mins)
Due           2014-04-01 00:00:00
Until         2015-03-31 00:00:00
Last modified 2014-03-01 12:17:03 (24 secs)
UUID          64bcf8fd-74d5-40d2-9e57-1d6a5922cdfc
Urgency       2.4

Date                Modification
2014-03-01 12:17:03 Mask set to '-'.
                    Modified set to '2014-03-01 12:17:03'.copy

template mask

The template task now has a mask attribute, and some change history. That mask is a string of task statuses. It has a value of - which indicates that one instance was created, task 124, because it is one character long. The - means that instance is still pending. This is how the template task keeps track of what it does and does not need to generate. When the task instance changes status that - becomes + (completed) or X (deleted) or W (waiting).

Note that you never directly interact with task 123, the template task. It is hidden for a reason. Instead, you interact with the recurring task instances, and in most cases, changes are propagated to the template task and optionally other sibling tasks.

In this example one task instance is generated for the next due period. This is because the configuration setting recurrence.limit is set to 1, the default. If this number is increased to 2, then you would see the next 2 instances generated. Note that this only generates two steps into the future, without regard for whether those two instances are completed or not - don’t expect to complete the first task and see a new one pop up immediately.

##filter

The <filter> consists of zero or more restrictions on which tasks to select, such as:
  task                                      <command> <mods>
  task 28                                   <command> <mods>
  task +weekend                             <command> <mods>
  task project:Home due.before:today        <command> <mods>
  task ebeeab00-ccf8-464b-8b58-f7f2d606edfb <command> <mods>

By default, filter elements are combined with an implicit 'and' operator, but 'or' and 'xor' may also be used, provided parentheses are included:
  task '(/[Cc]at|[Dd]og/ or /[0-9]+/)'      <command> <mods>

A filter may target specific tasks using ID or UUID numbers.  To specify multiple tasks use one of these forms:
  task 1,2,3                                    delete
  task 1-3                                      info
  task 1,2-5,19                                 modify pri:H
  task 4-7 ebeeab00-ccf8-464b-8b58-f7f2d606edfb infocopy

###Tags, Virtual Tags

Tags are arbitrary words, any quantity:

+tag The + means add the tag -tag The - means remove the tag

The basic tag syntax is very powerful and simple to use. There are two ways to use this, shown here:

task +HOME list
task -WORK listcopy

These two commands illustrate the complete tag interface. The first command is a filter that lists only tasks that have the HOME tag. The second command is a filter that lists only tasks that do not have the WORK tag. The + and - syntax therefore means presence and absence of a tag. This is simple to use, and can be combined like this:

task +HOME -WORK listcopy

This shows tasks that have the HOME tag, but do not have the WORK tag. This is a very simple and easy to use mechanism, but it does require that your tasks are properly tagged. In other words, it is based directly on task metadata.

A tag may be any single word that does not start with a digit, punctuation, or mathematical operator.

####Supported Virtual Tags

Since version 2.2.0, Taskwarrior has supported virtual tags, and the list will continue to grow. Here is the full list of supported virtual tags:

• BLOCKED - Is the task dependent on another incomplete task?
• UNBLOCKED - The opposite of BLOCKED, for convenience. Note +BLOCKED == -UNBLOCKED and vice versa.
• BLOCKING - Does another task depend on this incomplete task?
• DUE - Is this task due within 7 days? Determined by rc.due
• DUETODAY - Is this task due sometime today?
• TODAY - Is this task due sometime today?
• OVERDUE - Is this task past its due date?
• WEEK - Is this task due this week? 2.3.0
• MONTH - Is this task due this month? 2.3.0
• QUARTER - Is this task due this quarter? 2.6.0
• YEAR - Is this task due this year? 2.3.0
• ACTIVE - Is the task active, i.e. does it have a start date?
• SCHEDULED - Is the task scheduled, i.e. does it have a scheduled date?
• PARENT - Is the task a hidden parent recurring task? 2.3.0
• CHILD - Is the task a recurring child task?
• UNTIL - Does the task expire, i.e. does it have an until date?
• WAITING - Is the task hidden, i.e. does it have a wait date?
• ANNOTATED - Does the task have any annotations?
• READY - Is the task pending, not blocked, and either not scheduled, or scheduled before now. 2.4.0
• YESTERDAY - Was the task due yesterday? 2.4.0
• TOMORROW - Is the task due tomorrow? 2.4.0
• TAGGED - Does the task have any tags?
• PENDING - Is the task in the pending state? 2.4.0
• COMPLETED - Is the task in the completed state? 2.4.0
• DELETED - Is the task in the deleted state? 2.4.0
• UDA - Does the task contain any UDA values? 2.5.0
• ORPHAN - Does the task contain any orphaned UDA values? 2.5.0
• PRIORITY - Does the task have a priority? 2.5.0
• PROJECT - Does the task have a project? 2.5.0
• LATEST - Is the task the most recently added task? 2.5.0

###filters usage

####Complex Filters

Some Taskwarrior filters are simple in concept, but the syntax is not that straightforward. For example, to determine whether a task has a due date that falls on the current day, you need to use this filter:

task due.after:yesterday and due.before:tomorrow listcopy

This filters tasks with a due date during the narrow time window of ’today’. Note that it is not sufficient to just specify the date, because due dates all have associated times (defaulting to 0:00:00), and if you want to match the date, you need to consider the time. So for example, this command does not list tasks due today:

task due:today listcopy

Instead, this filter matches tasks with a due date of today, and a time of 0:00. In order to see all tasks due today, you need to provide proper range bracketing.

####Simplification

Here is where virtual tags can help, by providing a simple tag interface to more complex state conditions of the task. There is a virtual tag, named TODAY that can be used in filters, and it means that instead of this filter:

task due.after:yesterday and due.before:tomorrow listcopy

We can now use this:

task +TODAY listcopy

Which is a much simpler way of filtering tasks due today. Because this is a tag interface, we can also invert it:

task -TODAY listcopy

This shows only tasks that are not due today.

Virtual tags are built in to Taskwarrior. They are evaluated at run time, which means they do not require direct metadata, and therefore do not occupy space in the database, but are determined according to the state of the task in the same way that the complex filter example above is determined.

Thus virtual tags combine the simplicity of the tag interface with more complex defined conditions, for convenience.

##Using Dates Effectively

A task does not require a due date, and can simply be a statement of need:

$ task add Send Alice a birthday cardcopy

However, this is exactly the kind of task can benefit from having a due date, and perhaps several other dates also.

There are several dates that can decorate a task, each with its own meaning and effects. You can choose to use some, all or none of these, but like all Taskwarrior features, they are there in case your needs require it, but you do not pay a performance or friction penalty by not using them.

###The due Date

Use a due date to specify the exact date by which a task must be completed. This corresponds to the last possible moment when the task can be considered on-time. Using our example, we can set the due date to be Alice’s birthday (line breaks added for clarity):

$ task add Send Alice a birthday card \
           due:2016-11-08copy

Now your task has an associated due date, to help you determine when you need to work on it. But what effect does this have on Taskwarrior? How can it be used to best advantage?

We call the due date of a task ‘metadata’. As such, it is just a piece of data associated with the task, and therefore it can become part of a filter:

$ task due:today list
...copy

This is one way to find out if any of your tasks are due today. You could also use:

$ task +TODAY list
...copy

That is an example of a virtual tag, TODAY, which is not a real tag, but is something you can query, and is equivalent to the previous example. Additionally, you can use DUE which filters tasks that have a due date today or within the next 7 days, or WEEK for all tasks due within the current calendar week, or YESTERDAY, TOMORROW, MONTH and YEAR.

Note that number of days in which a task is considered DUE can be configured using the rc.due setting.

You can find tasks that have any due date at all:

$ task due.any: list
...copy

Or no due date:

$ task due.none: list
...copy

There is also an overdue report that makes use of the OVERDUE virtual tag, to show you what is already late. If you run the calendar report, your due date will be highlighted on it.

What we see here is that Taskwarrior leverages the metadata to drive various features. Several reports will sort by due date, and as we see above, a task that has a due date now belongs on your schedule.

###The scheduled Date

A scheduled date is different from a due date, and represents the earliest opportunity to work on a task. Let’s continue with the same example above. You need to send a birthday card to Alice, but her birthday isn’t until November, so it’s not the kind of task that can be done in advance. Ideally this would be done a few days ahead of the due date:

$ task add Send Alice a birthday card \
           due:2016-11-08 \
           scheduled:2016-11-04copy

This means that you need to send Alice a birthday card, no later than 2016-11-08, and no earlier than 2016-11-04.

If a task has a scheduled date, then once that date passes, the task is considered ready, and there is a ready report and a READY virtual tag for this:

$ task ready
...
$ task +READY list
...copy

Tasks that have no scheduled date are considered always ready. Again, metadata drives the sophistication of your task list.

###The wait Date

Many people do not like to look at long task lists, finding them daunting, or just distracting. You can add a wait date to a task, which has the effect of hiding the task from you until that date. In our example, Alice’s birthday isn’t close yet, so we applied a scheduled date to indicate that we should not begin the task yet, as it is not ready. Now let’s add a wait date to the task:

$ task add Send Alice a birthday card \
           due:2016-11-08 \
           scheduled:2016-11-04 \
           wait:novembercopy

Here the task is given a wait date of 2016-11-01, via the useful shortcut ’november’, which means the task will not appear on lists until November. At that time, it will reappear, but it will still not be ready until 2016-11-04.

You can view all the hidden waiting tasks using the waiting report:

$ task waiting
...copy

There is a WAITING virtual tag to select these tasks, but note that you have to use the all report with it, otherwise you get conflicts with the other reports that specify a ‘pending’ status, because a waiting task is not pending.

###The until Date

Now suppose I miss Alice’s birthday completely. Shame on me. The task would be overdue, but this is the kind of task where I don’t want to complete it late, I’d rather just forget it, and wish Alice a belated happy birthday in person. I could simply delete or complete the task, but there is another option, which is to add an until date:

$ task add Send Alice a birthday card \
           due:2016-11-08 \
           scheduled:2016-11-04 \
           wait:november \
           until:2016-11-10copy

This means that on 2016-11-10, the task self-destructs, and is automatically deleted. This might be the right thing to do for a birthday card task, but is not suitable for a “Pay the rent” task. Beware!

There is a DOM-based shortcut you can use, to make the command above a little more formulaic:

$ task add Send Alice a birthday card \
           due:2016-11-08 \
           scheduled:due-4d \
           wait:due-7d \
           until:due+2dcopy

This is evaluated only at task creation time, so if you change the due date, you also need to change the other dates. Note there is an UNTIL virtual tag to show you all tasks that are set to auto-expire.

###Other Dates

There are other dates associated with a task, but these are more for internal use, and are less useful for you.

Each task has an entry date which records when it was created. Each completed or deleted task has an end date, which records when it was completed or deleted. An active, or started task has a start date, but only while it is in the active state. Finally, every task has a modification date, which records when it was last modified. This is used as a hint when tasks are being synced.

In addition, you may find you have a use case for a different kind of date for your task lists. For example, you may adhere to an agile development process, and a task may be assigned to a sprint, and that sprint may be identified by its end date. You can add arbitrary dates like this to Taskwarrior by defining a (UDA) and then storing that metadata with your tasks. In this case, Taskwarrior will do nothing with your UDA but store it, and let you use it in reports and filters.

###Urgency

The presence and values of date metadata in your tasks affects the urgency calculations. For example, if a task is blocked by a dependency, the urgency is reduced. Similarly, tasks that are ready have an elevated urgency.

##DOM - Document Object Model

Taskwarrior has a Document Object Model, or DOM, which defines a way to reference all the data managed by taskwarrior. You may be familiar with the DOM implemented by web browsers that let you access details on a page programmatically. For example:

document.getElementById("myAnchor").href;copy

Taskwarrior allows the same kind of data access in a similar form, for example:

task _get 1.descriptioncopy

This references the description text of task 1. There is a that queries data using a DOM reference. Let’s see it in action, by first creating a detailed task.

task add Buy milk due:tomorrow +store project:Home pri:H
task 1 info

Name          Value
------------- ------------------------------------------
ID            1
Description   Buy milk
Status        Pending
Project       Home
Priority      H
Entered       2014-09-28 21:53:59 (4 seconds)
Due           2014-09-29 00:00:00
Last modified 2014-09-28 21:53:59 (4 seconds)
Tags          store
UUID          c0ab2bf6-b4f5-45c2-8420-18ab4f1ba7e7
Urgency       16.56
                           project     1  *    1 =     1
                          priority     1  *    6 =     6
                              tags   0.8  *    1 =   0.8
                               due  0.73  *   12 =  8.76copy

All the attributes of that task are available via DOM references. Here are some examples:

$ task _get 1.description
Buy milk

$ task _get 1.uuid
c0ab2bf6-b4f5-45c2-8420-18ab4f1ba7e7

$ task _get c0ab2bf6-b4f5-45c2-8420-18ab4f1ba7e7.id
    1

$ task _get 1.due.year
2014

$ task _get 1.due.julian
272copy

###Supported References

system.version: The version of taskwarrior, for example:

$ task _get system.version
2.4.0copy

system.os: The operating system, for example:

$ task _get system.os
FreeBSDcopy

rc.: Any configuration value default, with any overrides from the .taskrc applied, then with any command line overrides applied last. For example:

$ task _get rc.data.location
~/.taskcopy

: Any task attribute. Note that no task ID or UUID is specified, so this variant is only useful on the command line like this:

$ task add Pay rent due:eom wait:'due - 3days'copy

Note that ‘due’ is a DOM reference from earlier on the command line.

.: Any attribute of the specified task ID. For example:

$ task add Fix the leak depends:3 scheduled:3.duecopy

This makes the new task dependent on task 3, and scheduled on the due date of task 3. Note that ‘3.due’ is a DOM reference of a specific task.

.: Any attribute of the specified task UUID, as above.

Any attribute that is of type date can be directly accessed as a date, or it can be accessed by the elements of that date. For example:

• <date>.year - 2.4.0 The year, for example:
  shell

  $ task _get 1.due.year
  2014copy

• <date>.month - 2.4.0 The month, for example:
  shell

  $ task _get 1.due.month
  9copy

• <date>.day - 2.4.0 The day of the month, for example:
  shell

  $ task _get 1.due.day
  29copy

• <date>.week - 2.4.0 The week number of the date, for example:
  shell

  $ task _get 1.due.week
  40copy

• <date>.weekday - 2.4.0 The numbered weekday of the date, where 0 is Sunday and 6 is Saturday. For example:
  shell

  $ task _get 1.due.weekday
  1copy

• <date>.julian - 2.4.0 The Julian day of the date, which is the day number of the date in the year. For example, January 1st is 1, February 10th is 41. For example:
  shell

  $ task _get 1.due.julian
  272copy

• <date>.hour - 2.4.0 The hour of the day, for example:
  shell

  $ task _get 1.due.hour
  0copy

• <date>.minute - 2.4.0 The minute of the hour, for example:
  shell

  $ task _get 1.due.minute
  0copy

• <date>.second - 2.4.0 The seconds of the minute, for example:
  shell

  $ task _get 1.due.second
  0copy

Tags can be accessed as a single item as an <attribute>, of the individual tags can be accessed:

• tags.<literal> - 2.4.0 Direct access, per-tag, for example:
  shell

  $ task _get 1.tag.home
  homecopy

  If the tag is present, it is shown, otherwise the result is blank, and Taskwarrior exits with a non-zero status.
  shell

  $ task _get 1.tag.DUE
  DUE
  $ task _get 1.tag.OVERDUEcopy

  Workѕ for virtual tags too, in the same manner.

Annotations are compound data structures, with two elements, which are description and entry. Annotations are accessed by an ordinal.

• annotations.<N>.description - 2.4.0 The description of the Nth annotation, for example:
  shell

  $ task _get 1.annotations.0.descriptioncopy

• annotations.<N>.entry - 2.4.0 The creation timestamp of the Nth annotation, for example:
  shell

  $ task _get 1.annotations.0.entrycopy

  Note that because entry is of type date, the individual elements can be addressed, as above, for example:
  shell

  $ task _get 1.annotations.0.entry.year
  2014copy

UDA values can be accessed in the same manner.

##plugins

发现一些插件可以把豆瓣的信息导入到obsidian，可以作为阅读管理统计。

首先是豆瓣的 ，可以登陆豆瓣账户，然后可以同步自己的书影音。

导出划线，这个和豆瓣的不能是同一个文件，会有同步的问题。可以看完了再把划线移动到其他文档。

用bookshelf来查看，和记录阅读进度。这个似乎可以用base之类的方法代替。

##模板配置

###豆瓣

book

---
title: {{title}}
lists: {{type}}
score: {{score}}
rating: {{myRating}}
originalTitle: {{originalTitle}}
published: {{datePublished}}
pages: {{totalPage}}
author: {{author}}
tags: {{myTags}}
state: {{myState}}
url: {{url}}
country: {{country}}
language: {{language}}
time: {{time}}
comment: {{desc}}
cover:
---

# {{title}}

![image]({{image}})

comment: {{desc}}

{{myComment}}

doubanId: {{id}}

## logcopy

movie

---
doubanId: {{id}}
title: {{title}}
lists: {{type}}
score: {{score}}
rating: {{myRating}}
originalTitle: {{originalTitle}}
published: {{datePublished}}
director: {{director}}
actor: {{actor}}
author: {{author}}
tags: {{myTags}}
url: {{url}}
aliases: {{aliases}}
country: {{country}}
language: {{language}}
time: {{time}}
comment: {{desc}}
cover:
---

# {{title}}
![]({{image}})
IMDb: {{IMDb}}copy

###weread

这个是只导出划线和高亮没有评论，因为我不怎么在微信阅读写评论。

---
title: {{ metaData.title }}
lists: book
author: {{ metaData.author }}
time: {{ metaData.publishTime }}
comment: {{ metaData.intro }}
cover: {{ metaDate.cover }}
---

![{{metaData.title}}|200]({{metaData.cover}})

作者： {{metaData.author}}
简介： {{metaData.intro}}
类型： {{metaData.category}}

## highlights

{% for chapter in chapterHighlights %}### {{chapter.chapterTitle}}

{% for highlight in chapter.highlights %}- {{ highlight.markText |trim }}
{% endfor %}
{% endfor %}copy

###bookshelf

这个json可以直接放在obsidian-repo/.obsidian/plugins/bookshelf/data.json中。

{
    "settingsVersion": 20250408,
    "booksFolder": "gallery",
    "bookProperties": {
        "cover": "cover",
        "author": "author",
        "published": "published",
        "pages": "pages",
        "tags": "tags",
        "rating": "rating",
        "lists": "lists",
        "comment": "comment",
        "links": "links",
        "series": "series",
        "positionInSeries": "position-in-series",
        "duration": "duration"
    },
    "bookNote": {
        "enabled": true,
        "heading": "log",
        "dateFormat": "yyyy-MM-dd",
        "patterns": {
            "started": "{date}: Started",
            "finished": "{date}: Finished",
            "abandoned": "{date}: Abandoned",
            "absoluteProgress": "{date}: {start}-{end}",
            "relativeProgress": "{date}: {end}"
        }
    },
    "dailyNote": {
        "enabled": true,
        "heading": "Reading",
        "patterns": {
            "started": "Started {{book}}",
            "finished": "Finished {book}",
            "abandoned": "Abandoned {book}",
            "absoluteProgress": "Read {book}: {start}-{end}",
            "relativeProgress": "Read {book}: {end}"
        }
    },
    "readingProgress": {
        "newEntryLocation": "bookNote"
    },
    "previousVersion": "0.18.0",
    "showReleaseNotes": true
}copy

##解释

我的文件放在obsidian-repo/gallery/目录下，用bookshelf的lists来区分书、电影和音乐

##note

##comment

use following to comment mulilines:

\iffalse
comments
another line
\ficopy

\newcommand{\chen}[1]{{\textcolor{red}{[Chen: #1]}}}
\newcommand{\liu}[1]{{\textcolor{magenta}{[Liu: #1]}}}
\newcommand{\wang}[1]{{\textcolor{blue}{[Wang: #1]}}}

\begin{document}
\liu{test}

\chen{test}

\wang{test}
\end{document}copy

##diff

latexdiff to diff in pdf. tldr:

  Determine differences between two LaTeX files.
  More information: <https://ctan.org/pkg/latexdiff>.

  Determine changes between different versions of a LaTeX file (the resulting LaTeX file can be compiled to show differences underlined):

      latexdiff old.tex new.tex > diff.tex

  Determine changes between different versions of a LaTeX file by highlighting differences in boldface:

      latexdiff --type=BOLD old.tex new.tex > diff.tex

  Determine changes between different versions of a LaTeX file, and display minor changes in equations with both added and deleted graphics:

      latexdiff --math-markup=fine --graphics-markup=both old.tex new.tex > diff.texcopy

git-latexdiff compare pdf in git history

Important options:

Usage: git latexdiff [options] OLD [NEW]
OLD and NEW are Git revision identifiers. NEW defaults to HEAD.
If "--" is used for NEW, then diff against the working directory.
    --latex               run latex instead of pdflatex
    --xelatex             run xelatex instead of pdflatex
    --lualatex            run lualatex instead of pdflatex
    --main <file>         name of the main LaTeX, R Sweave,
    --tmpdirprefix        where temporary directory will be created (default: /tmp).
                            Relative path will use repository root as a base
    --ignore-latex-errors keep on going even if latex gives errors, so long as
                          a PDF file is producedcopy

For example, use git latexdiff HEAD -- --tmpdirprefix tmp --main main.tex to check differences between worktree and last commit.

##picture

If fix position:

\usepackage{float} % 在导言区添加
\usepackage{graphicx} % 用于插入图片

...

\begin{figure}[H] % 使用 [H] 固定位置
    \centering
    \includegraphics[width=0.8\textwidth]{example-image}
    \caption{固定位置的图片}
    \label{fig:example}
\end{figure}copy

centering:

\usepackage{graphicx} % 在导言区添加

...

{
    \centering
    \includegraphics[width=0.8\textwidth]{example-image}
    \par % 确保居中生效
}copy

\(\latex\)

##vimtex

vimtex基本上是提供了全套的功能，包括

• 目录，标签等
• 各种环境，insert模式下的各种snippets，normal模式下的文本对象和命令
• 编译，报错
• 正向搜索（从tex定位到pdf）和反向搜索（从pdf定位到tex）
• conceal （有点影响性能）

而且帮助文档非常详尽，维护积极，而且vim上也能用

缺点几乎没有，除了对与某些信奉unix哲学做一件事并做到最好的人（比如说我）来说有些臃肿。另一个是预设置的快捷键很多，但不一定符合所有人习惯（又是我）。

##latex

首先需要一个latex发行版，比如texlive或者miktex。实际编译过程很复杂，为了生成目录和参考文献需要多次编译。但是latexmk可以帮助完成复杂的顺序。最重要的是，latexmk可以监听文本变化，自动重新编译，以此实现“实时”预览。

实际上不是实时。会在每次保存文件时编译，所以insert模式下敲字时并不会更新。另一方面还取决于编译速度。

在archlinux上，可以安装整个texlive，如果觉得太臃肿也可以安装其中部分包，例如我只安装了

texlive-bibtexextra
texlive-binextra
texlive-langchinese
texlive-latexextra
texlive-mathscience
texlive-pstricks
texlive-xetexcopy

除此之外还有tectonic等可用，但是难以实现实时预览。

可以用texpresso

##lsp

texlab

tex-fmt

##compile

原则上可以直接用命令行编译。但是既然在neovim里，可以用插件封装的命令。

用vimtex或texlab

##inverse and reverse search

##snippets

###mathzone

为了在文本和数学公式环境中使用不同的片段，例如CC只在数学公式中自动展开为\mathbb{C}，需要对能检测数学环境。

最简单的方法是调用vimtex的功能。

用python检测。

用treesitter检测。

###engine

UltiSnip

LuaSnip

My on github.

There is a of my config, for fun.

I’m using nvim as a code editor, mainly for latex and markdown.

##Usage

###latex

using vimtex to detect math environment, and texlab lsp to complie.

cmp blink.cmp and ultisnips luasnip to enhance editing.

check .

###markdown

mkdnflow to enhance.

leadermp to open markdown-preview This is not necessary. Just render it in the terminal.

##Detail Configure

###options

in /lua/config/options.lua

###lsp

Config lsp by native nvim. Steal serval functions from nvim-lspconfig.

###plugins

I am using lazy.nvim as my plugins manager. Plugins are divided in serval classes, and following are some of mostly used plugins:

• edit: enhance for editing
  • ,
  • ,
  • , gJ and gK to split or joint
  • treej
  • , 中文输入自动切换
  • ,
  • zen mode, focus on editing
  • , like a temporary git
  • , translate words
  • , jump anywhere
  • ,
  • , commute ultisnips with cmp
  • , lsp source
  • , source from other buffers
  • , path source
  • , snippets
  • , copilot source
• editor: enhance for latex and markdown
  • , for latex
  • , preview md in browser
  • , render md in nvim
  • , help edit list, table etc in nvim
• git: using git in nvim
  • , show git status at left, jump by hunks
  • , show diff with history files
  • neogit
• lsp:
  • , Configure lsp
  • , install lsp
  • , jump by definitions, references etc
  • , jump by symbols etc
• file explorer:
  • , file tree
  • , yazi (tui file manager) in float terminal
  • snacks.picker.explorer, part of
• fuzzy finder
  • ,
  • snacks.picker, part of
• ui:
  • , my theme
  • , show color like #123dfe
  • , modeline, bufferline etc
  • , show indent line etc
• enhance native functions:
  • , plugin manager
  • , : cmd and / search
  • , show leader key sequence
  • , search and replace
  • , show start up time
  • , sudo write files

##miscellanea

##Install and basic setting

##Plugins

zotero 7:

常用：

• Zotero attanger
• Del item with Attachment
• Ethereal Reference

好用：

• zotero better notes

没必要但可以：

• Ethereal Style
• Attachment Scanner
• arXiv Workflow for zotero
• Zoplicate
• Linter for zotero

##Sync

using zotmoov attanger to move files

zotero 7 to rename:

{{ title case="snake" }}{{ creators case="snake" prefix="_" max="1"}}{{ year prefix="_" }}copy

use any cloud drive to sync. I’m using koofr.

##zotero better notes

用来

templates: you can copy these:

# This template is specifically for importing/sharing, using better
# notes 'import from clipboard': copy the content and
# goto Zotero menu bar, click Tools->New Template from Clipboard.
# Do not copy-paste this to better notes template editor directly.
name: "[QuickInsertV2]"
zoteroVersion: "7.0.9.SOURCE.fadbf3d2d"
pluginVersion: "2.0.18"
savedAt: "2024-11-07T07:59:45.835Z"
content: |-
  // @use-markdown
  <a href="${link}">${linkText}</a> [md](/wiki/math/zotero/${subNoteItem.getNoteTitle ? subNoteItem.getNoteTitle().replace(/[/\\?%*:|"<> ]/g, "-") + "-":""}${subNoteItem.key})copy

# This template is specifically for importing/sharing, using better
# notes 'import from clipboard': copy the content and
# goto Zotero menu bar, click Tools->New Template from Clipboard.
# Do not copy-paste this to better notes template editor directly.
name: "[QuickImportV2]"
zoteroVersion: "7.0.9.SOURCE.fadbf3d2d"
pluginVersion: "2.0.18"
savedAt: "2024-11-07T05:54:37.696Z"
content: |-
  <blockquote>
  ${{
    return await Zotero.BetterNotes.api.convert.link2html(link, {noteItem, dryRun: _env.dryRun});
  }}$
  </blockquote>copy

# This template is specifically for importing/sharing, using better
# notes 'import from clipboard': copy the content and
# goto Zotero menu bar, click Tools->New Template from Clipboard.
# Do not copy-paste this to better notes template editor directly.
name: "[QuickNoteV5]"
zoteroVersion: "7.0.9.SOURCE.fadbf3d2d"
pluginVersion: "2.0.18"
savedAt: "2024-11-07T05:54:55.255Z"
content: |-
  ${{
    let res = "";
    if (annotationItem.annotationComment) {
      res += await Zotero.BetterNotes.api.convert.md2html(
        annotationItem.annotationComment
      );
    } else {
  	res += "No comment";
    }
    return res;
  }}$

  // @use-markdown
  ***
  ${{
  	let res = "";
    res += await Zotero.BetterNotes.api.convert.annotations2html([annotationItem], {noteItem, ignoreComment: true});
    return res;
  }}$copy

# This template is specifically for importing/sharing, using better
# notes 'import from clipboard': copy the content and
# goto Zotero menu bar, click Tools->New Template from Clipboard.
# Do not copy-paste this to better notes template editor directly.
name: "[ExportMDFileNameV2]"
zoteroVersion: "7.0.9.SOURCE.fadbf3d2d"
pluginVersion: "2.0.18"
savedAt: "2024-11-07T05:55:24.890Z"
content: |-
  ${(noteItem.getNoteTitle ? noteItem.getNoteTitle().replace(/[/\\?%*:|"<> ]/g, "-") + "-" : "")}${noteItem.key}.mdcopy

# This template is specifically for importing/sharing, using better
# notes 'import from clipboard': copy the content and
# goto Zotero menu bar, click Tools->New Template from Clipboard.
# Do not copy-paste this to better notes template editor directly.
name: "[ExportMDFileHeaderV2]"
zoteroVersion: "7.0.9.SOURCE.fadbf3d2d"
pluginVersion: "2.0.18"
savedAt: "2024-11-07T05:55:34.047Z"
content: |-
  ${{
    let header = {};
    header.tags = noteItem.getTags().map((_t) => _t.tag);
    header.parent = noteItem.parentItem
      ? noteItem.parentItem.getField("title")
      : "";
    header.collections = (
      await Zotero.Collections.getCollectionsContainingItems([
        (noteItem.parentItem || noteItem).id,
      ])
    ).map((c) => c.name);
    return JSON.stringify(header);
  }}$copy

# This template is specifically for importing/sharing, using better
# notes 'import from clipboard': copy the content and
# goto Zotero menu bar, click Tools->New Template from Clipboard.
# Do not copy-paste this to better notes template editor directly.
name: "[ExportMDFileContent]"
zoteroVersion: "7.0.9.SOURCE.fadbf3d2d"
pluginVersion: "2.0.18"
savedAt: "2024-11-07T05:56:22.434Z"
content: |-
  ${{
    let start = mdContent;
    let rmspan = start.replace(/<\/?span.*?>/g,'');
    let pdflink = rmspan.replace(/(<a .*?open.*?>)“(.*?)”/g,'$2 $1(pdf)</a>');
    let dir2zotero = pdflink.replace(/<a href.*?zhref="(.*?)" ztype.*?>/g,'<a href="$1">');
    return dir2zotero;
  }}$copy

annotation will be exported as

<span class="highlight" data-annotation="<data-annotation>" ztype="zhighlight"><a href="zotero://open/library/items/G4BKVA2X?page=2&#x26;annotation=LZLEYYRJ">“<content>”</a></span> <span class="citation" data-citation="<citation>" ztype="zcitation">(<span class="citation-item"><a href="zotero://select/library/items/GLXUZZJT"></a></span>)</span>copy

the color of annotation is coded as %23<rgb> in <data-annotation>, for example blue (#2ea8e5) annotation is %232ea8e5

##plugins

常用：

• remotely save (using webdav to synchronize files)
• obsidian web clipper 浏览器插件

好用：

• git
• digital garden
• share as gist

没必要：

• gistr: 和share as gist比不能添加description
• find orphaned files and broken links

about vim:

• vim toggle
• vim input method switch
• vimrc
• edit in neovim

展示：

• dataview (display files by metadata)
• kanban (plan things, especially something with many stages)不习惯

##theme

• nord
• minimal

##sync

因为 ，所以重点是同步obsidian仓库。云端是github和webdav（koofr），在两台电脑（都是win/linux双系统）和手机、ipad，总计6个仓库同步。要注意的是

• 手机和ipad很难用git
• 设置需要忽略的文件
• 考虑用插件还是外部命令
• 各种方式下的冲突文件处理

##editor

虽然用obsidian管理markdown文件，但编辑器可以用其他的。比如 .

##shell and terminal

• zsh

• starship

• st

  • tabbed

• foot

• kitty

• mtm

• tmux

• tuios

##wm

• X
  • dwm
  • xorg-xeye: help to find xwayland app while running wayland
  • xev wev: key stroke under X and wayland
• wayland
  • river
  • hyprland
  • mangowc
• tty
  • dvtm

other:

Related tools

is a nested X server that runs as an X application.

If you wish to run a nested X window, you will need to specify a new display:

$ Xephyr -br -ac -noreset -screen 800x600 :1copy

This will launch a new Xephyr window with a DISPLAY of “:1”. In order to launch an application in that window, you would need to specify that display:

$ DISPLAY=:1 xtermcopy

If you want to launch a specific WM, for example, you would type:

$ DISPLAY=:1 spectrwmcopy

You can also launch Xephyr with your using startx:

$ startx -- /usr/bin/Xephyr :1copy

Grabbing and un-grabbing user input: Pressing Ctrl+Shift should lock/unlock your mouse pointer and your keystrokes inside Xephyr window exclusively if possible.
If using KDE, create a window rule to ignore global shortcuts. Then you can use Alt+Tab inside Xephyr.

Tips and tricks: Other examples for situations where Xephyr can be useful are:

1. A testing environment for an X application, or feature, in which the tester would like to keep working in their usual X environment, yet defending the other applications from failures of the application under test.
2. emphasize 3 settings in the sshd server configuration file for (over ssh). 2 of these, out of 3, are the default settings. When the ssh client can not influence the ssh server administrator to set the 3rd one, X11Forwarding, to yes, uses Xephyr as a work around to be installed in the ssh client machine.

##DE

• launcher
  • rofi
  • dmenu
• utils
  • dms
  • noctalia
  • iwd, impala
  • pipewire, wiremix
  • bluez, bluetui
  • power-profiles-daemon
• pcmanfm, Thunar, yazi
• fcitx5
• waterfox, brave

Editor

• neovim
  • cbfmt format code blocks inside markdown
• latex:
  • languagetool,
  • hunspell-en_us,
  • texstudio
• word: abiword
• pdf: sioyek, zathura, pdfbooklet
• markdown: obsidian

media:

• python-eye3: edit meta data for mp3
• mpd
  • frontend for mpd:
  • cli:mpc
  • easytag to edit metadata of a audio file.
  • tui:
    • ncmpc
    • ncmpcpp
    • mmtc (no, weird config)
    • rmpc
• mpv
  • mpvpaper: wallpaper by mpv in wayland
• a bilibili downloader
• wired
• ffmpeg
• A tui video editor. Use mpv to play and ffmpeg to edit.
• pic
  • feh
  • flameshot
  • picgo

##system and kernal

• stacer: trash cleaner, monitor

• btop: usage monitor

• btrfs-assistant

• timeshift

• snapper

• disk usage 感觉还是dua好用，图示其实用处不大

  • dua: du 的替代品，我一般用dua -i交互式查看
  • bonsai: gnome的baobab（kde的filelight）的tui版本，旭日图那个
  • diskonaut: 类似treesize, wiztree的方格划分的
  • btrfs-heatmap: btrfs usage by hilbert curve
  • gparted

• systemd

  • systemctl-tui
  • isd

• aconfmgr: A configuration manager for Arch Linux. Kind of like nixOS.

• linux-firmware: Since linux-firmware is departed, only need some of them. Use arch-checkfw to find which.

  linux-firmware includes

  TEXT

  Depends On      : linux-firmware-amdgpu  linux-firmware-atheros
                  linux-firmware-broadcom  linux-firmware-cirrus  linux-firmware-intel
                  linux-firmware-mediatek  linux-firmware-nvidia  linux-firmware-other
                  linux-firmware-radeon  linux-firmware-realtek
  Optional Deps   : linux-firmware-liquidio: Firmware for Cavium LiquidIO server adapters
                  linux-firmware-marvell: Firmware for Marvell devices
                  linux-firmware-mellanox: Firmware for Mellanox Spectrum switches
                  linux-firmware-nfp: Firmware for Netronome Flow Processors
                  linux-firmware-qcom: Firmware for Qualcomm SoCs
                  linux-firmware-qlogic: Firmware for QLogic devicescopy

• dracut: Alter for mkinitcpio

• Alter for grub not support fo timeshift btrfs snap yet

• , another snapper, not support fo timeshift btrfs snap yet

• kmscon alternative getty and tty, support unicode

• for arch

  • lostfiles find orphaned files not owned by Arch package
  • archstatus
  • arch-wiki-doc wikiman
  • pacfiles pacman -F alternative
  • pacman-contrib

##useful tools

• calendar, task, email, rss, etc

  • dstask
  • todo.txt
  • timewarrior
  • taskwarrior
    • tasknc
    • taskwarriortui
  • todoman
  • vdirsyncer
  • khal
  • todoman
  • aerc
  • newsboat

• git and related

  • lazygit: 最常用的
  • jujustu
  • gitlogue
  • serie
  • gitoxide An idiomatic, lean, fast & safe pure Rust implementation of Git
  • avc
  • github-cli

• cronboard :

• 本地一键部署docker，似乎很好用

• is a lightweight tool to locally create containers for multiple Linux distributions.

• is a container wrapping layer that allows the user to install containerised versions of Linux that are different to the host while providing tight integration with the host allowing the use of binaries designed for one distribution to run on another. Distrobox itself is not a container manager and relies on Podman or Docker to create containers.

• is a gui for Distrobox.

• surge: tui download manager

• darkhttpd

• nginx

• httrack

• whois

  tldr

  Command-line client for the WHOIS (RFC 3912) protocol.
  More information: <https://manned.org/whois>.
  
  Get information about a domain name:
  
      whois example.com
  
  Get information about an IP address:
  
      whois 8.8.8.8
  
  Get abuse contact for an IP address:
  
      whois -b 8.8.8.8copy

• stew-bin: install binary from github

• for terminal and shell

  • cat pdf or other
  • ripgrep-all: rga to match in pdf
  • lsix: list pictures by sixel
  • chafa: show pixels of pictures through sixel
  • gping: render in tui for ping
    • fv-cli show font in terminal using sixel iterm or kitty

• ffcast

• fbterm

• drive

  • : Filesystem client based on SSH.
  • koofr
  • rclone

• hardware

  • zmk-studio
  • librepod

sshfs username@remote_host:remote_directory mountpoint

umount mountpoint

# Mount remote directory from server with specific port: -p
# Use compression: -C
# Follow symbolic links: -o follow_symlinks

sshfs -o follow_symlinks username@remote_host:remote_directory mountpoint -p 2222 -Ccopy

##tui

##Interesting

• genect: 假装很忙的shell操作屏幕保护程序
• pipes-rs: 屏幕保护程序
• cmd-wrapped: summarize shell history
• diagon draw things in ascii
• gitmal: generate a site from a git repo
• generate pictures of code snaps
• Turn markdown with additional marks to pdf or html, like LaTeX.

  

  

• gowall: A tool to convert a wallpaper’s colorscheme, like nord or onedark
• activate-linux a watermark

##serves

• A modern, open-source, self-hosted knowledge management and note-taking platform designed for privacy-conscious users and organizations.
  但是开发很迅速，导致api乱七八糟，迷茫。而且似乎没有导出功能，只是能把附件存储在cloudflare上。还是要想办法备份一下。包括radicale也是。
• openlist
• radicale