디노트: 매뉴얼:

개인 용도 학습용

Changelog

[2023-11-10 Fri 14:46]

• 2024-03-27 use internal link how to?
• 2023-11-10 문서 포크 자동 번역 및 포멧팅
• 2023-11-14 메뉴얼 리딩 - Virtual Dired 적용 방법 연구

Denote (denote.el)

프로테실라오스 스타브로우

🏆 I provide private lessons on Emacs, Linux, and Life in general: https://protesilaos.com/coach/. Lessons continue throughout the year.

저는 Emacs, Linux 및 생활 전반에 대한 개인 레슨을 제공합니다: https://protesilaos.com/coach/. 수업은 일 년 내내 계속됩니다.

Simple notes for Emacs with an efficient file-naming scheme

효율적인 파일 명명 체계를 갖춘 Emac 용 간단한 노트

This manual, written by Protesilaos Stavrou, describes the customization options for the Emacs package called denote (or denote.el), and provides every other piece of information pertinent to it.

Protesilaos Stavrou 가 작성한 이 설명서에서는 denote (또는 denote.el )라는 Emacs 패키지의 사용자 지정 옵션에 대해 설명하며, 이와 관련된 다른 모든 정보를 제공합니다.

The documentation furnished herein corresponds to stable version 2.0.0, released on 2023-07-21. Any reference to a newer feature which does not yet form part of the latest tagged commit, is explicitly marked as such.

여기에 제공된 문서는 2023-07-21 에 릴리스된 안정 버전 2.0.0 에 해당합니다. 아직 태그가 지정된 최신 커밋의 일부가 아닌 최신 기능에 대한 언급은 명시적으로 그렇게 표시되어 있습니다.

Current development target is 2.1.0-dev.

현재 개발 목표는 2.1.0-dev 입니다.

• Package name (GNU ELPA): denote

  패키지 이름(GNU ELPA): denote

• Official manual: https://protesilaos.com/emacs/denote

  공식 매뉴얼: https://protesilaos.com/emacs/denote

• Change log: https://protesilaos.com/emacs/denote-changelog

  변경 로그: https://protesilaos.com/emacs/denote-changelog

• Git repo on SourceHut: https://git.sr.ht/~protesilaos/denote

  SourceHut 의 Git 리포지토리: https://git.sr.ht/~protesilaos/denote

  • Mirrors: 거울:
    • GitHub: https://github.com/protesilaos/denote
    • GitLab: https://gitlab.com/protesilaos/denote

• Mailing list: https://lists.sr.ht/~protesilaos/denote

  메일링 리스트: https://lists.sr.ht/~protesilaos/denote

• Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/

  비디오 데모: https://protesilaos.com/codelog/2022-06-18-denote-demo/

• Backronyms: Denote Everything Neatly; Omit The Excesses. Don't Ever Note Only The Epiphenomenal.

  반의어: 모든 것을 깔끔하게 표시하고 불필요한 것은 생략하세요. 경이로운 것만 메모하지 마세요.

If you are viewing the README.org version of this file, please note that the GNU ELPA machinery automatically generates an Info manual out of it.

이 파일의 README.org 버전을 보고 있는 경우, GNU ELPA 기계가 이 파일에서 자동으로 정보 설명서를 생성한다는 점에 유의하시기 바랍니다.

2. Overview

Denote aims to be a simple-to-use, focused-in-scope, and effective note-taking and file-naming tool for Emacs.

Denote 는 사용이 간편하고, 범위에 집중할 수 있으며, 효과적인 Emac 용 노트 필기 및 파일 이름 지정 도구를 목표로 합니다.

Denote is based on the idea that files should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the contents are about, without reference to any other metadata. Denote basically streamlines the creation of such files or file names while providing facilities to link between them (where those files are editable).

Denote 는 파일은 예측 가능하고 설명적인 파일 명명 체계를 따라야 한다는 생각에 기반합니다. 파일 이름은 다른 메타데이터를 참조하지 않고도 콘텐츠의 내용을 명확하게 나타낼 수 있어야 합니다. Denote 는 기본적으로 이러한 파일 또는 파일 이름 생성을 간소화하는 동시에 파일 간에 연결할 수 있는 기능을 제공합니다(해당 파일을 편집할 수 있는 경우).

Denote's file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a constistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.

Denote 의 파일 이름 지정 체계는 "노트"에만 국한되지 않습니다. 동영상과 같이 Emac 에서 편집할 수 없는 파일을 포함해 모든 유형의 파일에 사용할 수 있습니다. 일관된 방식으로 파일 이름을 지정하면 필터링과 검색이 훨씬 쉬워집니다. Denote 는 파일 유형에 관계없이 파일 이름을 바꿀 수 있는 관련 기능을 제공합니다.

Denote is based on the following core design principles:

Denote 는 다음과 같은 핵심 디자인 원칙을 기반으로 합니다:

Predictability예측 가능성 : File names must follow a consistent and descriptive naming convention (). The file name alone should offer a clear indication of what the contents are, without reference to any other metadatum. This convention is not specific to note-taking, as it is pertinent to any form of file that is part of the user's long-term storage ().

파일 이름은 일관되고 설명적인 명명 규칙(파일 명명 체계)을 따라야 합니다. 다른 메타데이터를 참조하지 않고도 파일 이름만으로도 콘텐츠가 무엇인지 명확하게 알 수 있어야 합니다. 이 규칙은 사용자가 장기 보관하는 모든 형태의 파일과 관련이 있으므로 노트 필기에만 적용되는 것은 아닙니다( 파일 이름 바꾸기).

Composability구성 가능성 : Be a good Emacs citizen, by integrating with other packages or built-in functionality instead of re-inventing functions such as for filtering or greping. The author of Denote (Protesilaos, aka “Prot”) writes ordinary notes in plain text (.txt), switching on demand to an Org file only when its expanded set of functionality is required for the task at hand ().

필터링이나 그리핑과 같은 기능을 다시 발명하는 대신 다른 패키지나 기본 제공 기능과 통합하여 훌륭한 Emacs 시민이 되세요. Denote 의 저자(Protesilaos, 일명 "Prot")는 일반 노트를 일반 텍스트로 작성하고( `.txt` ), 당면한 작업에 확장된 기능 세트가 필요할 때만 필요에 따라 Org 파일로 전환합니다( 진입 지점).

Portability휴대성 : Notes are plain text and should remain portable. The way Denote writes file names, the front matter it includes in the note's header, and the links it establishes must all be adequately usable with standard Unix tools. No need for a database or some specialised software. As Denote develops and this manual is fully fleshed out, there will be concrete examples on how to do the Denote-equivalent on the command-line.

노트는 일반 텍스트이며 이식성을 유지해야 합니다. Denote 가 파일 이름을 작성하는 방식, 노트 헤더에 포함시키는 앞부분 내용, 노트가 설정하는 링크는 모두 표준 Unix 도구에서 적절하게 사용할 수 있어야 합니다. 데이터베이스나 특수 소프트웨어가 필요 없습니다. Denote 가 발전하고 이 매뉴얼이 완전히 구체화되면 명령줄에서 Denote 와 동등한 작업을 수행하는 방법에 대한 구체적인 예가 추가될 것입니다.

Flexibility유연성 : Do not assume the user's preference for a note-taking methodology. Denote is conceptually similar to the Zettelkasten Method, which you can learn more about in this detailed introduction: https://zettelkasten.de/introduction/. Notes are atomic (one file per note) and have a unique identifier. However, Denote does not enforce a particular methodology for knowledge management, such as a restricted vocabulary or mutually exclusive sets of keywords. Denote also does not check if the user writes thematically atomic notes. It is up to the user to apply the requisite rigor and/or creativity in pursuit of their preferred workflow ().

사용자가 선호하는 노트 필기 방법론을 가정하지 마세요. Denote 는 제텔카스텐 방법과 개념적으로 유사하며, 자세한 소개는 <https://zettelkasten.de/introduction/> 에서 확인하실 수 있습니다. 노트는 원자적이며(노트당 하나의 파일) 고유 식별자가 있습니다. 하지만 Denote 는 제한된 어휘나 상호 배타적인 키워드 세트와 같은 지식 관리를 위한 특정 방법론을 강요하지 않습니다. 또한, Denote 는 사용자가 주제별 원자 노트를 작성하는지 여부를 확인하지 않습니다. 사용자가 선호하는 워크플로우(메타노트 작성)를 추구하기 위해 필요한 엄격함 및/또는 창의성을 적용하는 것은 사용자의 몫입니다.

Hackability해킹 가능성 : Denote's code base consists of small and reusable functions. They all have documentation strings. The idea is to make it easier for users of varying levels of expertise to understand what is going on and make surgical interventions where necessary (e.g. to tweak some formatting). In this manual, we provide concrete examples on such user-level configurations ().

Denote 의 코드 베이스는 작고 재사용 가능한 함수들로 구성되어 있습니다. 이 함수들은 모두 문서화 문자열을 가지고 있습니다. 이는 다양한 수준의 전문 지식을 가진 사용자가 무슨 일이 일어나고 있는지 쉽게 이해하고 필요한 경우 외과적 개입(예: 일부 서식 조정)을 할 수 있도록 하기 위함입니다. 이 매뉴얼에서는 이러한 사용자 수준별 구성에 대한 구체적인 예를 제공합니다(일기 또는 일기 쓰기).

Now the important part... “Denote” is the familiar word, though it also is a play on the “note” concept. Plus, we can come up with acronyms, recursive or otherwise, of increasingly dubious utility like:

이제 중요한 부분은... '표시'는 친숙한 단어이지만 '노트' 개념을 차용한 것이기도 합니다. 또한 재귀적이든 그렇지 않든 점점 더 활용도가 모호해지는 약어들을 생각해낼 수 있습니다:

• Don't Ever Note Only The Epiphenomenal

  경이로운 것만 기록하지 마세요.

• Denote Everything Neatly; Omit The Excesses

  모든 것을 깔끔하게 표시하고 불필요한 것은 생략하세요.

But we'll let you get back to work. Don't Eschew or Neglect your Obligations, Tasks, and Engagements.

하지만 다시 업무에 복귀할 수 있도록 도와드리겠습니다. 의무, 업무, 계약을 회피하거나 소홀히 하지 마세요.

3. Points of entry

There are five main ways to write a note with Denote: invoke the denote, denote-type, denote-date, denote-subdirectory, denote-template, denote-signature commands, or leverage the org-capture-templates by setting up a template which calls the function denote-org-capture. We explain all of those in the subsequent sections. Other more specialised commands exist as well, which one shall learn about as they read through this manual. We do not want to overwhelm the user with options at this stage.

denote , denote-type , denote-date , denote-subdirectory , denote-template , denote-signature 명령을 호출하거나, denote-org-capture 함수를 호출하는 템플릿을 설정해 org-capture-templates 을 활용하는 방법 등 다섯 가지 주요 방법으로 노트를 작성할 수 있습니다. 이 모든 방법은 다음 섹션에서 설명합니다. 이 매뉴얼을 읽으면서 더 전문화된 다른 명령어들도 존재하며, 이 명령어들에 대해 알아보도록 하겠습니다. 이 단계에서는 옵션이 너무 많아 사용자에게 부담을 주고 싶지 않습니다.

3.1. Standard note creation

3.1. 표준 노트 만들기

The denote command will prompt for a title. If a region is active, the text of the region becomes the default at the minibuffer prompt (meaning that typing RET without any input will use the default value). Once the title is supplied, the denote command will then ask for keywords. The resulting note will have a file name as already explained:

denote 명령은 제목을 입력하라는 메시지를 표시합니다. 영역이 활성화되어 있으면 미니버퍼 프롬프트에서 해당 영역의 텍스트가 기본값이 됩니다(즉, 아무 입력 없이 RET 을 입력하면 기본값이 사용됨). 제목을 입력하면 denote 명령이 키워드를 묻습니다. 결과 노트는 이미 설명한 대로 파일 이름을 갖게 됩니다: 파일 명명 체계

The denote command runs the hook denote-after-new-note-hook after creating the new note. [ Part of 2.1.0-dev. ]

denote 명령은 새 노트를 만든 후 denote-after-new-note-hook 훅을 실행합니다. [2.1.0 개발 버전에 포함됨 ]

The file type of the new note is determined by the user option denote-file-type ().

새 노트의 파일 유형은 사용자 옵션 denote-file-type ( 앞부분)에 의해 결정됩니다.

The keywords' prompt supports minibuffer completion. Available candidates are those defined in the user option denote-known-keywords. More candidates can be inferred from the names of existing notes, by setting denote-infer-keywords to non-nil (which is the case by default).

키워드 프롬프트는 미니버퍼 완성을 지원합니다. 사용 가능한 후보는 사용자 옵션 denote-known-keywords 에 정의된 후보입니다. denote-infer-keywords 을 nil 로 설정하면 기존 노트의 이름에서 더 많은 후보를 유추할 수 있습니다(기본값).

Multiple keywords can be inserted by separating them with a comma (or whatever the value of the crm-separator is---which should be a comma). When the user option denote-sort-keywords is non-nil (the default), keywords are sorted alphabetically (technically, the sorting is done with string-lessp).

여러 개의 키워드를 쉼표로 구분하여 삽입할 수 있습니다(또는 crm-separator 의 값은 쉼표가 되어야 함). 사용자 옵션 denote-sort-keywords 이 nil(기본값)이 아닌 경우 키워드는 알파벳순으로 정렬됩니다(기술적으로는 string-lessp 으로 정렬됩니다).

The interactive behaviour of the denote command is influenced by the user option denote-prompts ().

denote 명령의 대화형 동작은 사용자 옵션 denote-prompts (표시 프롬프트 옵션)의 영향을 받습니다.

The denote command can also be called from Lisp. Read its doc string for the technicalities.

denote 명령은 Lisp 에서도 호출할 수 있습니다. 자세한 내용은 해당 문서 문자열을 참조하세요.

In the interest of discoverability, denote is also available under the alias denote-create-note.

검색 편의성을 위해 denote 는 별칭 denote-create-note 으로도 사용할 수 있습니다.

3.1.1. The denote-prompts option

3.1.1. denote-prompts 옵션

The user option denote-prompts determines how the denote command will behave interactively ().

사용자 옵션 denote-prompts 은 denote 명령의 대화형 작동 방식을 결정합니다(표준 노트 생성).

The value is a list of symbols, which includes any of the following:

값은 다음 중 하나를 포함하는 기호 목록입니다:

• title: Prompt for the title of the new note.

  title : 새 노트의 제목을 입력하라는 메시지를 표시합니다.

• keywords: Prompts with completion for the keywords of the new note. Available candidates are those specified in the user option denote-known-keywords. If the user option denote-infer-keywords is non-nil, keywords in existing note file names are included in the list of candidates. The keywords prompt uses completing-read-multiple, meaning that it can accept multiple keywords separated by a comma (or whatever the value of crm-sepator is).

  keywords : 새 노트의 키워드를 입력하라는 메시지가 표시됩니다. 사용 가능한 후보 키워드는 사용자 옵션 denote-known-keywords 에 지정된 것들입니다. 사용자 옵션 denote-infer-keywords 이 0 이 아닌 경우, 기존 노트 파일 이름의 키워드가 후보 목록에 포함됩니다. keywords 프롬프트는 completing-read-multiple 을 사용하므로 쉼표로 구분된 여러 키워드(또는 crm-sepator 의 값에 상관없이)를 받아들일 수 있습니다.

• file-type: Prompts with completion for the file type of the new note. Available candidates are those specified in the user option denote-file-type. Without this prompt, denote uses the value of denote-file-type.

  file-type : 새 노트의 파일 형식을 입력하라는 메시지가 표시됩니다. 사용 가능한 후보는 사용자 옵션 denote-file-type 에 지정된 것들입니다. 이 프롬프트가 없으면 denote 은 denote-file-type 의 값을 사용합니다.

• subdirectory: Prompts with completion for a subdirectory in which to create the note. Available candidates are the value of the user option denote-directory and all of its subdirectories. Any subdirectory must already exist: Denote will not create it.

  subdirectory : 노트를 만들 하위 디렉터리를 입력하라는 메시지를 표시합니다. 사용 가능한 후보로는 denote-directory 사용자 옵션의 값과 그 하위 디렉터리 전체가 있습니다. 모든 하위 디렉터리는 이미 존재해야 합니다: 표시하면 만들지 않습니다.

• date: Prompts for the date of the new note. It will expect an input like 2022-06-16 or a date plus time: 2022-06-16 14:30. Without the date prompt, the denote command uses the current-time.

  date : 새 노트의 날짜를 입력하라는 메시지입니다. 2022-06-16 또는 날짜와 시간(2022-06-16 14:30)과 같은 입력이 예상됩니다. date 프롬프트가 없는 경우, denote 명령은 current-time 를 사용합니다.

  .

  표시 날짜-프롬프트 사용-조직 읽기 날짜 옵션.

• template: Prompts for a KEY among the denote-templates. The value of that KEY is used to populate the new note with content, which is added after the front matter ().

  template : denote-templates 중 KEY 를 입력하라는 메시지를 표시합니다. 해당 KEY 의 값은 앞부분('템플릿 표시' 옵션) 뒤에 추가되는 콘텐츠로 새 노트를 채우는 데 사용됩니다.

• signature: - Prompts for an arbitrary string that can be used to establish a sequential relationship between files (e.g. 1, 1a, 1b, 1b1, 1b2, ...). Signatures have no strictly defined function and are up to the user to apply as they see fit. One use-case is to implement Niklas Luhmann's Zettelkasten system for a sequence of notes (Folgezettel). Signatures are not included in a file's front matter. They are reserved solely for creating a sequence in a file listing, at least for the time being. To insert a link that includes the signature, use the command denote-link-with-signature (). [ The denote-link-with-signature is part of 2.1.0-dev. ]

  signature : - 파일 간의 순차적 관계를 설정하는 데 사용할 수 있는 임의의 문자열을 입력하라는 메시지(예: 1, 1a, 1b, 1b1, 1b2, ...)를 표시합니다. 서명은 엄격하게 정의된 기능이 없으며 사용자가 적절하다고 판단되는 대로 적용할 수 있습니다. 한 가지 사용 사례는 일련의 노트(폴게제텔)를 위해 Niklas Luhmann 의 제텔카스텐 시스템을 구현하는 것입니다. 서명은 파일의 앞부분에 포함되지 않습니다. 서명은 적어도 당분간은 파일 목록에서 시퀀스를 만들기 위한 용도로만 사용됩니다. 서명이 포함된 링크를 삽입하려면 denote-link-with-signature (서명이 있는 파일에 링크 삽입) 명령을 사용합니다. [ denote-link-with-signature 는 2.1.0-dev 에 포함되어 있습니다.]

The prompts occur in the given order.

프롬프트는 주어진 순서대로 표시됩니다.

If the value of this user option is nil, no prompts are used. The resulting file name will consist of an identifier (i.e. the date and time) and a supported file type extension (per denote-file-type).

이 사용자 옵션의 값이 nil 이면 프롬프트가 사용되지 않습니다. 결과 파일 이름은 식별자(예: 날짜 및 시간)와 지원되는 파일 형식 확장자( denote-file-type )로 구성됩니다.

Recall that Denote's standard file-naming scheme is defined as follows ():

Denote 의 표준 파일 이름 지정 체계는 다음과 같이 정의되어 있습니다(파일 이름 지정 체계):

DATE--TITLE__KEYWORDS.EXT

If either or both of the title and keywords prompts are not included in the value of this variable, file names will be any of those permutations:

title 및 keywords 프롬프트 중 하나 또는 둘 다 이 변수 값에 포함되지 않은 경우 파일 이름은 해당 순열 중 하나가 됩니다:

DATE.EXT
DATE--TITLE.EXT
DATE__KEYWORDS.EXT

When in doubt, always include the title and keywords prompts.

확실하지 않은 경우 항상 title 및 keywords 프롬프트를 포함하세요.

Finally, this user option only affects the interactive use of the denote command (advanced users can call it from Lisp). For ad-hoc interactive actions that do not change the default behaviour of the denote command, users can invoke these convenience commands: denote-type, denote-subdirectory, denote-date, denote-signature. They are described in the subsequent section ().

마지막으로, 이 사용자 옵션은 denote 명령의 대화형 사용에만 영향을 줍니다(고급 사용자는 Lisp 에서 이 명령을 호출할 수 있음). denote 명령의 기본 동작을 변경하지 않는 임시 대화형 작업의 경우 사용자는 다음과 같은 편의 명령을 호출할 수 있습니다: denote-type , denote-subdirectory , denote-date , denote-signature . 이 명령들은 다음 섹션( 노트 생성을 위한 편의 명령)에 설명되어 있습니다.

3.1.2. The denote-templates option

3.1.2. denote-templates 옵션

The user option denote-templates is an alist of content templates for new notes. A template is arbitrary text that Denote will add to a newly created note right below the front matter.

사용자 옵션 denote-templates 은 새 노트의 콘텐츠 템플릿 목록입니다. 템플릿은 회원님이 새로 만든 노트의 제목 바로 아래에 추가할 수 있는 임의의 텍스트입니다.

Templates are expressed as a (KEY . STRING) association.

템플릿은 (KEY . STRING) 연결로 표현됩니다.

• The KEY is the name which identifies the template. It is an arbitrary symbol, such as report, memo, statement.

  KEY 은 템플릿을 식별하는 이름입니다. report , memo , statement 와 같은 임의의 기호입니다.

• The STRING is ordinary text that Denote will insert as-is. It can contain newline characters to add spacing. Below we show some concrete examples.

  STRING 은 일반 텍스트로, Denote 에서 그대로 삽입합니다. 공백을 추가하기 위해 개행 문자를 포함할 수 있습니다. 아래에서 몇 가지 구체적인 예를 보여드리겠습니다.

The user can choose a template either by invoking the command denote-template or by changing the user option denote-prompts to always prompt for a template when calling the denote command.

사용자는 denote-template 명령을 호출하거나 사용자 옵션 denote-prompts 을 변경하여 denote 명령을 호출할 때 항상 템플릿을 묻는 메시지를 표시하도록 설정하여 템플릿을 선택할 수 있습니다.

.

표시 프롬프트 옵션입니다.

.

노트 생성을 위한 편리한 명령어.

Templates can be written directly as one large string. For example (the \n character is read as a newline):

템플릿은 하나의 큰 문자열로 직접 작성할 수 있습니다. 예를 들어 \n 문자는 개행으로 읽힙니다:

(setq denote-templates
      '((report . "* Some heading\n\n* Another heading")
        (memo . "* Some heading
 
* Another heading
 
")))

Long strings may be easier to type but interpret indentation literally. Also, they do not scale well. A better way is to use some Elisp code to construct the string. This would typically be the concat function, which joins multiple strings into one. The following is the same as the previous example:

긴 문자열은 입력하기가 더 쉬울 수 있지만 들여쓰기를 문자 그대로 해석합니다. 또한 확장성이 좋지 않습니다. 더 나은 방법은 Elisp 코드를 사용하여 문자열을 구성하는 것입니다. 일반적으로 여러 문자열을 하나로 결합하는 concat 함수를 사용합니다. 다음은 이전 예제와 동일합니다:

(setq denote-templates
      `((report . "* Some heading\n\n* Another heading")
        (memo . ,(concat "* Some heading"
                         "\n\n"
                         "* Another heading"
                         "\n\n"))))

Notice that to evaluate a function inside of an alist we use the backtick to quote the alist (NOT the straight quote) and then prepend a comma to the expression that should be evaluated. The concat form here is not sensitive to indentation, so it is easier to adjust for legibility.

목록 내에서 함수를 평가하려면 백틱을 사용하여 목록(곧은 따옴표가 아님)을 인용한 다음 평가해야 하는 표현식에 쉼표를 추가합니다. 여기서 concat 양식은 들여쓰기에 민감하지 않으므로 가독성을 위해 조정하기가 더 쉽습니다.

DEV NOTE: We do not provide more examples at this point, though feel welcome to ask for help if the information provided herein is not sufficient. We shall expand the manual accordingly.

개발 참고: 현재로서는 더 많은 예시를 제공하지 않지만, 여기에 제공된 정보가 충분하지 않은 경우 언제든지 도움을 요청하시기 바랍니다. 그에 따라 매뉴얼을 확장할 예정입니다.

3.1.3. Convenience commands for note creation

3.1.3. 노트 생성을 위한 편리한 명령

Sometimes the user needs to create a note that has different requirements from those of denote (). While this can be achieved globally by changing the denote-prompts user option, there are cases where an ad-hoc method is the appropriate one ().

사용자가 denote (표준 노트 만들기)의 요구사항과 다른 요구사항이 있는 노트를 만들어야 할 때가 있습니다. 이는 denote-prompts 사용자 옵션을 변경해 전역적으로 달성할 수 있지만, 임시 방법이 적절한 경우도 있습니다('표시 프롬프트' 옵션).

To this end, Denote provides the following convenience interactive commands for note creation:

이를 위해 Denote 는 노트 생성을 위한 다음과 같은 편리한 대화형 명령을 제공합니다:

• Create note by specifying file type

  파일 형식을 지정하여 노트 만들기 :: The denote-type command creates a note while prompting for a file type.

  denote-type 명령은 파일 형식을 묻는 메시지를 표시하면서 노트를 만듭니다.

  This is the equivalent to calling denote when denote-prompts is set to '(file-type title keywords). In practical terms, this lets you produce, say, a note in Markdown even though you normally write in Org ().

  이는 denote-prompts 이 '(file-type title keywords) 로 설정되어 있을 때 denote 를 호출하는 것과 같습니다. 실용적인 용어로, 예를 들어 보통은 Org(표준 노트 생성)로 작성하지만 마크다운으로 노트를 만들 수 있습니다.

  The denote-create-note-using-type is an alias of denote-type.

  denote-create-note-using-type 은 denote-type 의 별칭입니다.

• Create note using a date

  날짜를 사용하여 노트 만들기 :: Normally, Denote reads the current date and time to construct the unique identifier of a newly created note (). Sometimes, however, the user needs to set an explicit date+time value.

  일반적으로 Denote 는 현재 날짜와 시간을 읽어 새로 만든 노트의 고유 식별자를 구성합니다(표준 노트 생성). 하지만 사용자가 명시적인 날짜+시간 값을 설정해야 하는 경우도 있습니다.

  This is where the denote-date command comes in. It creates a note while prompting for a date. The date can be in YEAR-MONTH-DAY notation like 2022-06-30 or that plus the time: 2022-06-16 14:30.

  denote-date 명령이 필요한 이유입니다. 이 명령은 날짜를 입력하라는 메시지를 표시하면서 노트를 만듭니다. 날짜는 2022-06-30 와 같은 연월일 표기법 또는 여기에 시간을 더한 2022-06-16 14:30 과 같이 입력할 수 있습니다.

  .

  표시 날짜-프롬프트 사용-조직 읽기 날짜 옵션.

  This is the equivalent to calling denote when denote-prompts is set to '(date title keywords).

  이는 denote-prompts 이 '(date title keywords) 으로 설정된 경우 denote 을 호출하는 것과 같습니다.

  The denote-create-note-using-date is an alias of denote-date.

  denote-create-note-using-date 은 denote-date 의 별칭입니다.

• Create note in a specific directory

  특정 디렉터리에 노트 만들기 :: The denote-subdirectory command creates a note while prompting for a subdirectory. Available candidates include the value of the variable denote-directory and any subdirectory thereof (Denote does not create subdirectories).

  denote-subdirectory 명령은 하위 디렉터리를 묻는 메시지를 표시하면서 메모를 만듭니다. 사용 가능한 후보에는 denote-directory 변수 값과 그 하위 디렉터리가 포함됩니다(Denote 는 하위 디렉터리를 만들지 않음).

  This is equivalent to calling denote when denote-prompts is set to '(subdirectory title keywords).

  이는 denote-prompts 이 '(subdirectory title keywords) 으로 설정된 경우 denote 으로 호출하는 것과 같습니다.

  The denote-create-note-in-subdirectory is a more descriptive alias of denote-subdirectory.

  denote-create-note-in-subdirectory 은 denote-subdirectory 의 보다 설명적인 별칭입니다.

• Create note and add a template

  노트 만들기 및 템플릿 추가 :: The denote-template command creates a new note and inserts the specified template below the front matter (). Available candidates for templates are specified in the user option denote-templates.

  denote-template 명령은 새 노트를 만들고 제목 아래에 지정된 템플릿을 삽입합니다('템플릿 표시' 옵션). 사용 가능한 템플릿 후보는 사용자 옵션 denote-templates 에서 지정할 수 있습니다.

  This is equivalent to calling denote when denote-prompts is set to '(template title keywords).

  이는 denote-prompts 이 '(template title keywords) 으로 설정된 경우 denote 으로 호출하는 것과 같습니다.

  The denote-create-note-with-template is an alias of the command denote-template, meant to help with discoverability.

  denote-create-note-with-template 은 검색 가능성을 돕기 위한 denote-template 명령의 별칭입니다.

• Create note with a signature

  서명이 있는 노트 만들기 :: The denote-signature command first prompts for an arbitrary string to use in the optional SIGNATURE field of the file name and then asks for a title and keywords. Signatures are arbitrary strings of alphanumeric characters which can be used to establish sequential relations between file at the level of their file name (e.g. 1, 1a, 1b, 1b1, 1b2, ...).

  denote-signature 명령은 먼저 파일 이름의 선택적 SIGNATURE 필드에 사용할 임의의 문자열을 입력하라는 메시지를 표시한 다음 제목과 키워드를 묻습니다. 서명은 파일 이름 수준에서 파일 간의 순차적 관계를 설정하는 데 사용할 수 있는 영숫자로 구성된 임의의 문자열입니다(예: 1, 1a, 1b, 1b1, 1b2, ...).

  The denote-create-note-using-signature is an alias of the command denote-signature intended to make the functionality more discoverable.

  denote-create-note-using-signature 은 denote-signature 명령의 별칭으로, 기능을 더 쉽게 검색할 수 있도록 하기 위한 것입니다.

3.1.3.1. Write your own convenience commands

3.1.3.1. 나만의 편의 명령어 작성

The convenience commands we provide only cover some basic use-cases (). The user may require combinations that are not covered, such as to prompt for a template and for a subdirectory, instead of only one of the two. To this end, we show how to follow the code we use in Denote to write your own variants of those commands.

저희가 제공하는 편의 명령은 몇 가지 기본적인 사용 사례(노트 생성을 위한 편의 명령)에만 적용됩니다. 사용자는 템플릿과 하위 디렉터리를 묻는 메시지, 둘 중 하나만이 아닌 다른 조합을 요구할 수도 있습니다. 이를 위해 Denote 에서 사용하는 코드를 따라 이러한 명령의 변형을 직접 작성하는 방법을 보여드리겠습니다.

First let's take a look at the definition of one of those commands. They all look the same, but we use denote-subdirectory for this example:

먼저 이러한 명령 중 하나의 정의를 살펴보겠습니다. 모두 동일하게 보이지만 이 예에서는 denote-subdirectory 을 사용합니다:

(defun denote-subdirectory ()
  "Create note while prompting for a subdirectory.
 
Available candidates include the value of the variable
`denote-directory' and any subdirectory thereof.
 
This is equivalent to calling `denote' when `denote-prompts' is
set to '(subdirectory title keywords)."
  (declare (interactive-only t))
  (interactive)
  (let ((denote-prompts '(subdirectory title keywords)))
    (call-interactively #'denote)))

The hyphenated word after defun is the name of the function. It has to be unique. Then we have the documentation string (or “doc string”) which is for the user's convenience.

defun 뒤의 하이픈으로 연결된 단어가 함수 이름입니다. 고유해야 합니다. 그런 다음 사용자의 편의를 위한 문서 문자열(또는 "문서 문자열")이 있습니다.

This function is interactive, meaning that it can be called via M-x or be assigned to a key binding. Then we have the local binding of the denote-prompts to the desired combination (“local” means specific to this function without affecting other contexts). Lastly, it calls the standard denote command interactively, so it uses all the prompts in their specified order.

이 함수는 interactive 이며, M-x 을 통해 호출하거나 키 바인딩에 할당할 수 있습니다. 그런 다음 denote-prompts 를 원하는 조합에 로컬 바인딩합니다("로컬"은 다른 컨텍스트에 영향을 주지 않고 이 함수에만 해당됨을 의미함). 마지막으로 표준 denote 명령을 대화형으로 호출하므로 모든 프롬프트를 지정된 순서대로 사용합니다.

Now let's say we want to have a command that (i) asks for a template and (ii) for a subdirectory (). All we need to do is tweak the let bound value of denote-prompts and give our command a unique name:

이제 (i) 템플릿을 요청하고 (ii) 하위 디렉터리를 요청하는 명령어(denote-templates 옵션)를 만들고 싶다고 가정해 보겠습니다. let 바인딩 값 denote-prompts 을 조정하고 명령에 고유한 이름을 지정하기만 하면 됩니다:

;; Like `denote-subdirectory' but also ask for a template
(defun denote-subdirectory-with-template ()
  "Create note while also prompting for a template and subdirectory.
 
This is equivalent to calling `denote' when `denote-prompts' is
set to '(template subdirectory title keywords)."
  (declare (interactive-only t))
  (interactive)
  (let ((denote-prompts '(template subdirectory title keywords)))
    (call-interactively #'denote)))

The tweaks to denote-prompts determine how the command will behave (). Use this paradigm to write your own variants which you can then assign to keys or invoke with M-x.

denote-prompts 을 조정하면 명령의 작동 방식이 결정됩니다(표시 프롬프트 옵션). 이 패러다임을 사용하여 자신만의 변형을 작성한 다음 키에 할당하거나 M-x 로 호출할 수 있습니다.

3.1.4. The denote-date-prompt-use-org-read-date option

3.1.4. denote-date-prompt-use-org-read-date 옵션

By default, Denote uses its own simple prompt for date or date+time input (). This is done when the denote-prompts option includes a date symbol and/or when the user invokes the denote-date command.

기본적으로 Denote 는 날짜 또는 날짜+시간 입력에 대해 자체적인 간단한 프롬프트('denote-prompts' 옵션)를 사용합니다. 이는 denote-prompts 옵션에 date 기호가 포함되거나 사용자가 denote-date 명령을 호출할 때 수행됩니다.

Users who want to benefit from the more advanced date selection method that is common in interactions with Org mode, can set the user option denote-date-prompt-use-org-read-date to a non-nil value.

조직 모드와의 상호 작용에서 일반적으로 사용되는 고급 날짜 선택 방법을 활용하려는 사용자는 사용자 옵션 denote-date-prompt-use-org-read-date 을 null 이 아닌 값으로 설정할 수 있습니다.

3.1.5. Add or remove keywords interactively

3.1.5. 대화형 키워드 추가 또는 제거

The commands denote-keywords-add and denote-keywords-remove streamline the process of interactively updating a file's keywords in the front matter and renaming it accordingly.

denote-keywords-add 및 denote-keywords-remove 명령은 파일의 앞부분에 있는 키워드를 대화형으로 업데이트하고 그에 따라 파일 이름을 변경하는 프로세스를 간소화합니다.

The denote-keywords-add asks for keywords using the familiar minibuffer prompt (). It then renames the file ().

denote-keywords-add 화면은 익숙한 미니버퍼 프롬프트(표준 노트 만들기)를 사용해 키워드를 입력합니다. 그런 다음 파일 이름을 변경합니다( 제목에 따라 단일 파일 이름 변경).

Similarly, the denote-keywords-remove removes one or more keywords from the list of existing keywords and then renames the file accordingly.

마찬가지로 denote-keywords-remove 은 기존 키워드 목록에서 하나 이상의 키워드를 제거한 다음 그에 따라 파일 이름을 변경합니다.

3.2. Create note using Org capture

3.2. 조직 캡처를 사용해 노트 만들기

For integration with org-capture, the user must first add the relevant template. Such as:

org-capture 와 통합하려면 먼저 사용자가 관련 템플릿을 추가해야 합니다. 예를 들어

(with-eval-after-load 'org-capture
  (add-to-list 'org-capture-templates
               '("n" "New note (with Denote)" plain
                 (file denote-last-path)
                 #'denote-org-capture
                 :no-save t
                 :immediate-finish nil
                 :kill-buffer t
                 :jump-to-captured t)))

[ In the future, we might develop Denote in ways which do not require such manual intervention. More user feedback is required to identify the relevant workflows. ]

[ 향후에는 이러한 수동 개입이 필요 없는 방식으로 Denote 를 개발할 수도 있습니다. 관련 워크플로우를 파악하려면 더 많은 사용자 피드백이 필요합니다. ]

Once the template is added, it is accessed from the specified key. If, for instance, org-capture is bound to C-c c, then the note creation is initiated with C-c c n, per the above snippet. After that, the process is the same as with invoking denote directly, namely: a prompt for a title followed by a prompt for keywords ().

템플릿이 추가되면 지정된 키에서 액세스됩니다. 예를 들어, org-capture 가 C-c c 에 바인딩된 경우, 위의 스니펫에 따라 C-c c n 로 노트 생성이 시작됩니다. 그 후, 프로세스는 denote 를 직접 호출할 때와 동일합니다. 즉, 제목을 입력하라는 프롬프트와 키워드를 입력하라는 프롬프트가 이어집니다(표준 노트 생성).

Users may prefer to leverage org-capture in order to extend file creation with the specifiers described in the org-capture-templates documentation (such as to capture the active region and/or create a hyperlink pointing to the given context).

사용자는 org-capture-templates 문서에 설명된 지정자를 사용하여 파일 생성을 확장(예: 활성 영역 캡처 및/또는 지정된 컨텍스트를 가리키는 하이퍼링크 생성)하기 위해 org-capture 을 활용하는 것을 선호할 수 있습니다.

IMPORTANT. Due to the particular file-naming scheme of Denote, which is derived dynamically, such specifiers or other arbitrary text cannot be written directly in the template. Instead, they have to be assigned to the user option denote-org-capture-specifiers, which is interpreted by the function denote-org-capture. Example with our default value:

중요. 동적으로 파생되는 Denote 의 특정 파일 이름 지정 체계로 인해 이러한 지정자 또는 기타 임의의 텍스트를 템플릿에 직접 작성할 수 없습니다. 대신 사용자 옵션 denote-org-capture-specifiers 에 할당해야 하며, 이는 denote-org-capture 함수에 의해 해석됩니다. 기본값을 사용한 예시입니다:

(setq denote-org-capture-specifiers "%l\n%i\n%?")

Note that denote-org-capture ignores the denote-file-type: it always sets the Org file extension for the created note to ensure that the capture process works as intended, especially for the desired output of the denote-org-capture-specifiers.

denote-org-capture 은 denote-file-type 을 무시하고 생성된 노트의 파일 확장자를 항상 Org 로 설정해 캡처 프로세스가 의도대로 작동하도록 합니다(특히 denote-org-capture-specifiers 의 원하는 출력에 대해).

3.3. Create note with specific prompts using Org capture

3.3. 조직 캡처를 사용해 특정 프롬프트가 있는 노트 만들기

This section assumes knowledge of how Denote+org-capture work, as explained in the previous section ().

이 섹션에서는 이전 섹션('조직 캡처를 사용해 노트 만들기')에서 설명한 대로 Denote+조직 캡처의 작동 방식에 대한 지식이 있다고 가정합니다.

The previous section shows how to define an Org capture template that always prompts for a title and keywords. There are, however, cases where the user wants more control over what kind of input Denote will prompt for. To this end, we provide the function denote-org-capture-with-prompts. Below we explain it and then show some examples of how to use it.

이전 섹션에서는 항상 제목과 키워드를 묻는 메시지를 표시하는 조직 캡처 템플릿을 정의하는 방법을 보여드렸습니다. 그러나 사용자가 어떤 종류의 입력을 입력할지 더 세밀하게 제어하고 싶은 경우가 있습니다. 이를 위해 denote-org-capture-with-prompts 함수를 제공합니다. 아래에서 이 함수에 대해 설명한 다음 사용 방법에 대한 몇 가지 예를 보여드리겠습니다.

The denote-org-capture-with-prompts is like denote-org-capture but with optional prompt parameters.

denote-org-capture-with-prompts 은 denote-org-capture 과 같지만 프롬프트 매개변수(선택 사항)가 있습니다.

When called without arguments, it does not prompt for anything. It just returns the front matter with title and keyword fields empty and the date and identifier fields specified. It also makes the file name consist of only the identifier plus the Org file name extension.

인자 없이 호출하면 아무 메시지도 표시하지 않습니다. 제목 및 키워드 필드가 비어 있고 날짜 및 식별자 필드가 지정된 앞부분만 반환합니다. 또한 파일 이름이 식별자와 Org 파일 이름 확장자로만 구성되도록 합니다.

.

파일 이름 지정 체계입니다.

Otherwise, it produces a minibuffer prompt for every non-nil value that corresponds to the TITLE, KEYWORDS, SUBDIRECTORY, DATE, and TEMPLATE arguments. The prompts are those used by the standard denote command and all of its utility commands.

그렇지 않으면 TITLE , KEYWORDS , SUBDIRECTORY , DATE , TEMPLATE 인수에 해당하는 nil 이 아닌 모든 값에 대해 미니버퍼 프롬프트를 생성합니다. 이 프롬프트는 표준 denote 명령과 모든 유틸리티 명령에서 사용되는 프롬프트입니다.

.

진입 지점.

When returning the contents that fill in the Org capture template, the sequence is as follows: front matter, TEMPLATE, and then the value of the user option denote-org-capture-specifiers.

조직 캡처 템플릿을 채우는 콘텐츠를 반환할 때는 앞부분, TEMPLATE , 사용자 옵션 값 denote-org-capture-specifiers 의 순서를 따릅니다.

Important note: in the case of SUBDIRECTORY actual subdirectories must exist---Denote does not create them. Same principle for TEMPLATE as templates must exist and are specified in the user option denote-templates.

중요 참고: SUBDIRECTORY 의 경우 실제 하위 디렉터리가 존재해야 하며, 주석은 하위 디렉터리를 생성하지 않습니다. TEMPLATE 의 경우 템플릿이 존재해야 하며 사용자 옵션 denote-templates 에 지정되어 있는 것과 동일한 원칙입니다.

This is how one can incorporate denote-org-capture-with-prompts in their Org capture templates. Instead of passing a generic t which makes it hard to remember what the argument means, we use semantic keywords like :title for our convenience (internally this does not matter as the value still counts as non-nil, so :foo for TITLE is treated the same as :title or t).

이렇게 하면 denote-org-capture-with-prompts 를 조직 캡처 템플릿에 통합할 수 있습니다. 인수의 의미를 기억하기 어려운 일반 t 대신 편의를 위해 :title 같은 시맨틱 키워드를 사용합니다(내부적으로는 여전히 값이 0 이 아닌 것으로 계산되므로 TITLE 에 대한 :foo 은 :title 또는 t 와 동일하게 취급됩니다).

;; This prompts for TITLE, KEYWORDS, and SUBDIRECTORY
(add-to-list 'org-capture-templates
             '("N" "New note with prompts (with denote.el)" plain
               (file denote-last-path)
               (function
                (lambda ()
                  (denote-org-capture-with-prompts :title :keywords :subdirectory)))
               :no-save t
               :immediate-finish nil
               :kill-buffer t
               :jump-to-captured t))
 
;; This prompts only for SUBDIRECTORY
(add-to-list 'org-capture-templates
             '("N" "New note with prompts (with denote.el)" plain
               (file denote-last-path)
               (function
                (lambda ()
                  (denote-org-capture-with-prompts nil nil :subdirectory)))
               :no-save t
               :immediate-finish nil
               :kill-buffer t
               :jump-to-captured t))
 
;; This prompts for TITLE and SUBDIRECTORY
(add-to-list 'org-capture-templates
             '("N" "New note with prompts (with denote.el)" plain
               (file denote-last-path)
               (function
                (lambda ()
                  (denote-org-capture-with-prompts :title nil :subdirectory)))
               :no-save t
               :immediate-finish nil
               :kill-buffer t
               :jump-to-captured t))

3.4. Open an existing note or create it if missing

3.4. 기존 노트를 열거나 없는 경우 새로 만들기

[ Rewritten and expanded as part of 2.1.0-dev. ]

[ 2.1.0-dev 의 일부로 재작성 및 확장되었습니다.]

Sometimes it is necessary to briefly interrupt the ongoing writing session to open an existing note or, if that is missing, to create it. This happens when a new tangential thought occurs and the user wants to confirm that an entry for it is in place. To this end, Denote provides the command denote-open-or-create as well as its more flexible counterpart denote-open-or-create-with-command.

때때로 진행 중인 글쓰기 세션을 잠시 중단하고 기존 노트를 열거나, 노트가 없는 경우, 노트를 만들어야 할 때가 있습니다. 새로운 접선 아이디어가 떠오르고 사용자가 그에 대한 항목이 제자리에 있는지 확인하고 싶을 때 이런 일이 발생합니다. 이를 위해 Denote 는 denote-open-or-create 명령과 보다 유연한 대응 명령인 denote-open-or-create-with-command 명령을 제공합니다.

The denote-open-or-create prompts to visit a file in the denote-directory. At this point, the user must type in search terms that match a file name. If the input does not return any matches and the user confirms their choice to proceed (usually by typing RET twice, depending on the minibuffer settings), denote-open-or-create will call the denote command interactively to create a new note. It will then use whatever prompts denote normally has, per the user option denote-prompts (). If the title prompt is involved (the default behaviour), the denote-open-or-create sets up this prompt to have the previous input as the default title of the note to-be-created. This means that the user can type RET at the empty prompt to re-use what they typed in previously. Commands to use previous inputs from the history are also available (M-p or M-n in the minibuffer, which call previous-history-element and next-history-element by default). Accessing the history is helpful to, for example, make further edits to the available text.

denote-open-or-create denote-directory 에 있는 파일을 방문하라는 메시지가 표시됩니다. 이 때 사용자는 파일 이름과 일치하는 검색어를 입력해야 합니다. 입력해도 일치하는 항목이 없고 사용자가 계속 진행을 확인하면(보통 미니버퍼 설정에 따라 RET 을 두 번 입력) denote-open-or-create 은 denote 명령을 대화식으로 호출해 새 노트를 만듭니다. 그런 다음 사용자 옵션 denote-prompts (표준 노트 생성)에 따라 일반적으로 denote 프롬프트가 표시되는 것을 사용합니다. 제목 프롬프트가 포함된 경우(기본 동작), denote-open-or-create 명령은 이 프롬프트가 이전 입력을 새로 만들 노트의 기본 제목으로 사용하도록 설정합니다. 즉, 사용자는 빈 프롬프트에 RET 을 입력해 이전에 입력한 내용을 다시 사용할 수 있습니다. 히스토리의 이전 입력을 사용하는 명령도 사용할 수 있습니다(미니버퍼의 M-p 또는 M-n , 기본적으로 previous-history-element 및 next-history-element 호출). 기록에 액세스하면 사용 가능한 텍스트를 추가로 편집하는 등의 작업에 유용합니다.

The denote-open-or-create-with-command is like the above, except when it is about to create the new note it first prompts for the specific file-creating command to use (). For example, the user may want to specify a signature for this new file, so they can select the denote-signature command.

denote-open-or-create-with-command URL 은 위와 비슷하지만 새 노트를 만들려고 할 때 먼저 사용할 특정 파일 생성 명령어를 묻는 메시지가 표시됩니다(진입 지점). 예를 들어, 사용자가 이 새 파일의 서명을 지정하고 싶을 경우, denote-signature 명령을 선택할 수 있습니다.

Denote provides similar functionality for linking to an existing note or creating a new one ().

Denote 는 기존 노트에 연결하거나 새 노트를 만들 수 있는 유사한 기능을 제공합니다(노트에 연결하거나 누락된 경우 새로 만들기).

3.5. Maintain separate directory silos for notes

3.5. 노트를 위한 별도의 디렉토리 사일로 유지

The user option denote-directory accepts a value that represents the path to a directory, such as ~/Documents/notes. Normally, the user will have one place where they store all their notes, in which case this arrangement shall suffice.

사용자 옵션 denote-directory 은 ~/Documents/notes 과 같이 디렉터리 경로를 나타내는 값을 사용할 수 있습니다. 일반적으로 사용자는 모든 노트를 저장하는 장소가 한 곳일 텐데, 이 경우 이 설정으로 충분합니다.

There is, however, the possibility to maintain separate directories of notes. By “separate”, we mean that they do not communicate with each other: no linking between them, no common keywords, nothing. Think of the scenario where one set of notes is for private use and another is for an employer. We call these separate directories “silos”.

하지만 별도의 노트 디렉터리를 유지할 수도 있습니다. "분리"라는 말은 서로 연결되지 않고, 공통 키워드도 없고, 아무것도 소통하지 않는다는 뜻입니다. 한 노트 세트는 개인용이고 다른 노트 세트는 고용주용인 시나리오를 생각해 보세요. 저희는 이러한 별도의 디렉터리를 "사일로"라고 부릅니다.

To create silos, the user must specify a local variable at the root of the desired directory. This is done by creating a .dir-locals.el file, with the following contents:

사일로를 만들려면 사용자가 원하는 디렉터리의 루트에 로컬 변수를 지정해야 합니다. 이 작업은 다음 내용으로 .dir-locals.el 파일을 생성하여 수행합니다:

;;; Directory Local Variables.  For more information evaluate:
;;;
;;;     (info "(emacs) Directory Variables")
 
((nil . ((denote-directory . default-directory))))

When inside the directory that contains this .dir-locals.el file, all Denote commands/functions for note creation, linking, the inference of available keywords, et cetera will use the silo as their point of reference. They will not read the global value of denote-directory. The global value of denote-directory is read everywhere else except the silos.

이 .dir-locals.el 파일이 들어 있는 디렉터리 안에서는 노트 생성, 링크, 사용 가능한 키워드 추론 등을 위한 모든 Denote 명령/함수들이 사일로를 참조 지점으로 사용합니다. 이들은 denote-directory 의 글로벌 값을 읽지 않습니다. denote-directory 의 글로벌 값은 사일로를 제외한 다른 모든 곳에서 읽습니다.

.

사용자 지정 명령을 사용하여 사일로를 선택합니다.

In concrete terms, this is a representation of the directory structures (notice the .dir-locals.el file is needed only for the silos):

구체적으로 말하면, 이것은 디렉토리 구조의 표현입니다( .dir-locals.el 파일은 사일로에만 필요합니다):

;; This is the global value of 'denote-directory' (no need for a .dir-locals.el)
~/Documents/notes
|-- 20210303T120534--this-is-a-test__journal_philosophy.txt
|-- 20220303T120534--another-sample__journal_testing.md
`-- 20220620T181255--the-third-test__keyword.org
 
;; A silo with notes for the employer
~/different/path/to/notes-for-employer
|-- .dir-locals.el
|-- 20210303T120534--this-is-a-test__conference.txt
|-- 20220303T120534--another-sample__meeting.md
`-- 20220620T181255--the-third-test__keyword.org
 
;; Another silo with notes for my volunteering
~/different/path/to/notes-for-volunteering
|-- .dir-locals.el
|-- 20210303T120534--this-is-a-test__activism.txt
|-- 20220303T120534--another-sample__teambuilding.md
`-- 20220620T181255--the-third-test__keyword.org

It is possible to configure other user options of Denote to have a silo-specific value. For example, this one changes the denote-known-keywords only for this particular silo:

사일로별 값을 갖도록 Denote 의 다른 사용자 옵션을 구성할 수 있습니다. 예를 들어, 이 옵션은 이 특정 사일로에 대해서만 denote-known-keywords 을 변경합니다:

;;; Directory Local Variables.  For more information evaluate:
;;;
;;;     (info "(emacs) Directory Variables")
 
((nil . ((denote-directory . default-directory)
         (denote-known-keywords . ("food" "drink")))))

This one is like the above, but also disables denote-infer-keywords:

이것은 위와 같지만 denote-infer-keywords 도 비활성화합니다:

;;; Directory Local Variables.  For more information evaluate:
;;;
;;;     (info "(emacs) Directory Variables")
 
((nil . ((denote-directory . default-directory)
         (denote-known-keywords . ("food" "drink"))
         (denote-infer-keywords . nil))))

To expand the list of local variables to, say, cover specific major modes, we can do something like this:

예를 들어 특정 주요 모드를 포함하도록 로컬 변수 목록을 확장하려면 다음과 같이 할 수 있습니다:

;;; Directory Local Variables.  For more information evaluate:
;;;
;;;     (info "(emacs) Directory Variables")
 
((nil . ((denote-directory . default-directory)
         (denote-known-keywords . ("food" "drink"))
         (denote-infer-keywords . nil)))
 (org-mode . ((org-hide-emphasis-markers . t)
              (org-hide-macro-markers . t)
              (org-hide-leading-stars . t))))

IMPORTANT If your silo contains sub-directories of notes, you should replace default-directory in the above examples with an absolute path to your silo directory, otherwise links from files within the sub-directories cannot be made to files in the parent directory. For example:

중요 회원님의 사일로에 노트의 하위 디렉터리가 있는 경우, 위의 예에서 default-directory 를 회원님의 사일로 디렉터리의 절대 경로로 바꿔야 합니다. 그렇지 않으면 하위 디렉터리 안의 파일에서 상위 디렉터리의 파일로 링크를 만들 수 없습니다. 예를 들어

;;; Directory Local Variables.  For more information evaluate:
;;;
;;;     (info "(emacs) Directory Variables")
  ((nil . ((denote-directory . "~/my-silo")
           (denote-known-keywords . ("food" "drink"))
           (denote-infer-keywords . nil)))
   (org-mode . ((org-hide-emphasis-markers . t)
                (org-hide-macro-markers . t)
                (org-hide-leading-stars . t))))

As not all user options have a “safe” local value, Emacs will ask the user to confirm their choice and to store it in the Custom code snippet that is normally appended to init file (or added to the file specified by the user option custom-file).

모든 사용자 옵션에 "안전한" 로컬 값이 있는 것은 아니므로, Emac 은 사용자에게 선택 사항을 확인하고 일반적으로 초기 파일에 추가되는 사용자 지정 코드 스니펫에 저장하도록 요청합니다(또는 사용자 옵션으로 지정된 파일에 추가됨 custom-file ).

Finally, it is possible to have a .dir-locals.el for subdirectories of any denote-directory. Perhaps to specify a different set of known keywords, while not making the subdirectory a silo in its own right. We shall not expand on such an example, as we trust the user to experiment with the best setup for their workflow.

마지막으로 denote-directory 의 하위 디렉터리에 .dir-locals.el 을 가질 수 있습니다. 하위 디렉터리 자체를 사일로로 만들지 않으면서 다른 알려진 키워드 집합을 지정할 수도 있습니다. 사용자가 자신의 워크플로우에 가장 적합한 설정을 실험할 것으로 믿기 때문에 이러한 예시를 더 이상 확장하지 않겠습니다.

Feel welcome to ask for help if the information provided herein is not sufficient. The manual shall be expanded accordingly.

여기에 제공된 정보가 충분하지 않은 경우 언제든지 도움을 요청하세요. 본 매뉴얼은 그에 따라 확장될 것입니다.

3.5.1. Use custom commands to select a silo

3.5.1. 사용자 지정 명령을 사용하여 사일로 선택

[ As part of 2.1.0-dev, the contents of this section are formally provided in the file denote-silo-extras.el. We keep this here for existing users. Otherwise consult the new entry in the manual (). ]

[2.1.0-dev 의 일부로, 이 섹션의 내용은 denote-silo-extras.el 파일에 공식적으로 제공됩니다. 기존 사용자를 위해 이 내용을 여기에 보관합니다. 그렇지 않으면 매뉴얼의 새 항목( denote-silo-extras.el )을 참조하세요. ]

We implement silos as directory-local values of the user option denote-directory. This means that all Denote commands read from the local value if they are invoked from that context. For example, if ~/Videos/recordings is a silo and ~/Documents/notes is the default/global value of denote-directory all Denote commands will read the video's path when called from there (e.g. by using Emacs' dired); any other context reads the global value.

사용자 옵션 denote-directory 의 디렉터리-로컬 값으로 사일로를 구현합니다. 즉, 해당 컨텍스트에서 호출되는 경우 모든 Denote 명령이 로컬 값에서 읽습니다. 예를 들어 ~/Videos/recordings 가 사일로이고 ~/Documents/notes 이 denote-directory 의 기본/글로벌 값인 경우, 모든 Denote 명령은 해당 컨텍스트에서 호출될 때 비디오의 경로를 읽습니다(예: Emacs 의 dired 사용); 다른 컨텍스트에서는 글로벌 값을 읽습니다.

.

노트를 위한 별도의 디렉터리 사일로를 유지하세요.

There are cases where the user (i) wants to maintain multiple silos and (ii) prefers an interactive way to switch between them without going through Dired. Since this is specific to the user's workflow, it is easier to have some custom code for it. The following should be added to the user's Denote configuration:

사용자가 (i) 여러 사일로를 유지 관리하고 싶거나 (ii) Dired 를 거치지 않고 사일로 간에 전환할 수 있는 대화형 방식을 선호하는 경우가 있습니다. 이는 사용자의 워크플로에 따라 다르므로 사용자 지정 코드를 만드는 것이 더 쉽습니다. 사용자의 Denote 구성에 다음을 추가해야 합니다:

(defvar my-denote-silo-directories
  `("/home/prot/Videos/recordings"
    "/home/prot/Documents/books"
    ;; You don't actually need to include the `denote-directory' here
    ;; if you use the regular commands in their global context.  I am
    ;; including it for completeness.
    ,denote-directory)
  "List of file paths pointing to my Denote silos.
  This is a list of strings.")
 
(defvar my-denote-commands-for-silos
  '(denote
    denote-date
    denote-subdirectory
    denote-template
    denote-type)
  "List of Denote commands to call after selecting a silo.
  This is a list of symbols that specify the note-creating
  interactive functions that Denote provides.")
 
(defun my-denote-pick-silo-then-command (silo command)
  "Select SILO and run Denote COMMAND in it.
  SILO is a file path from `my-denote-silo-directories', while
  COMMAND is one among `my-denote-commands-for-silos'."
  (interactive
   (list (completing-read "Select a silo: " my-denote-silo-directories nil t)
         (intern (completing-read
                  "Run command in silo: "
                  my-denote-commands-for-silos nil t))))
  (let ((denote-user-enforced-denote-directory silo))
    (call-interactively command)))

With this in place, M-x my-denote-pick-silo-then-command will use minibuffer completion to select a silo among the predefined options and then ask for the command to run in that context.

이렇게 하면 M-x my-denote-pick-silo-then-command 은 미니버퍼 완성을 사용하여 미리 정의된 옵션 중에서 사일로를 선택한 다음 해당 컨텍스트에서 명령을 실행하도록 요청합니다.

Note the use of the variable user-enforced-denote-directory. This variable is specially meant for custom commands to select silos. When it is set, it overrides the global default value of denote-directory as well as the value provided by the .dir-locals.el file. Use it only when writing wrapper functions like my-denote-pick-silo-then-command.

user-enforced-denote-directory 변수의 사용에 유의하세요. 이 변수는 특별히 사일로를 선택하는 사용자 지정 명령을 위한 것입니다. 이 변수를 설정하면 글로벌 기본값인 denote-directory 및 .dir-locals.el 파일에서 제공하는 값을 재정의합니다. my-denote-pick-silo-then-command 와 같은 래퍼 함수를 작성할 때만 사용하세요.

To see another example of a wrapper function that uses user-enforced-denote-directory, see:

user-enforced-denote-directory 를 사용하는 래퍼 함수의 다른 예를 보려면 다음을 참조하세요:

.

표시 확장: 조직 하위 트리를 자체 노트로 분할합니다.

3.5.2. The denote-silo-extras.el

[ Part of 2.1.0-dev. ]

[ 2.1.0 개발 중 일부 ]입니다.

The denote-silo-extras.el provides optional convenience functions for working with silos (). Start by loading the relevant library:

denote-silo-extras.el 에서는 사일로 작업을 위한 선택적 편의 기능을 제공합니다(노트를 위한 별도의 디렉토리 사일로 유지). 관련 라이브러리를 불러오는 것으로 시작하세요:

(require 'denote-silo-extras)

The user option denote-silo-extras-directories specifies a list of directories that the user has set up as denote-directory silos.

사용자 옵션 denote-silo-extras-directories 은 사용자가 denote-directory 사일로로 설정한 디렉터리 목록을 지정합니다.

The command denote-silo-extras-create-note prompts for a directory among denote-silo-extras-directories and runs the denote command from there.

denote-silo-extras-create-note 명령은 denote-silo-extras-directories 중 디렉터리를 묻는 메시지를 표시하고 거기에서 denote 명령을 실행합니다.

Similar to the above, the command denote-silo-extras-open-or-create prompts for a directory among denote-silo-extras-directories and runs the denote-open-or-create command from there.

위와 유사하게 denote-silo-extras-open-or-create 명령은 denote-silo-extras-directories 중 디렉터리를 묻는 메시지를 표시하고 거기에서 denote-open-or-create 명령을 실행합니다.

The command denote-silo-extras-select-silo-then-command prompts with minibuffer completion for a directory among denote-silo-extras-directories. Once the user selects a silo, a second prompt asks for a Denote note-creation command to call from inside that silo ().

denote-silo-extras-select-silo-then-command 명령은 denote-silo-extras-directories 중 하나의 디렉터리에 대한 미니버퍼를 완성하라는 메시지를 표시합니다. 사용자가 사일로를 선택하면 두 번째 프롬프트에서 해당 사일로 내부에서 호출할 노트 생성 명령(진입 지점)을 묻는 메시지가 표시됩니다.

3.6. Exclude certain directories from all operations

3.6. 모든 작업에서 특정 디렉토리 제외

The user option denote-excluded-directories-regexp instructs all Denote functions that read or check file/directory names to omit directories that match the given regular expression. The regexp needs to match only the name of the directory, not its full path.

사용자 옵션 denote-excluded-directories-regexp 은 파일/디렉토리 이름을 읽거나 확인하는 모든 Denote 함수에 지정된 정규식과 일치하는 디렉터리를 생략하도록 지시합니다. 정규식은 전체 경로가 아닌 디렉터리 이름만 일치하면 됩니다.

Affected operations include file prompts and functions that return the available files in the value of the user option denote-directory ().

영향을 받는 작업에는 사용자 옵션 denote-directory ('노트를 위한 별도의 디렉토리 사일로 유지')의 값으로 사용 가능한 파일을 반환하는 파일 프롬프트와 함수가 포함됩니다.

File prompts are used by several commands, such as denote-link and denote-subdirectory.

파일 프롬프트는 denote-link 및 denote-subdirectory 과 같은 여러 명령에서 사용됩니다.

Functions that check for files include denote-directory-files and denote-directory-subdirectories.

파일을 확인하는 함수에는 denote-directory-files 및 denote-directory-subdirectories 이 있습니다.

The match is performed with string-match-p.

경기는 string-match-p 로 수행됩니다.

.

개발자 또는 고급 사용자용.

3.7. Exclude certain keywords from being inferred

3.7. 특정 키워드를 유추에서 제외하기

The user option denote-excluded-keywords-regexp omits keywords that match a regular expression from the list of inferred keywords.

사용자 옵션 denote-excluded-keywords-regexp 은 추론된 키워드 목록에서 정규식과 일치하는 키워드를 생략합니다.

Keywords are inferred from file names and provided at relevant prompts as completion candidates when the user option denote-infer-keywords is non-nil.

사용자 옵션 denote-infer-keywords 이 0 이 아닌 경우 키워드는 파일 이름에서 추론되어 관련 프롬프트에서 완성 후보로 제공됩니다.

The match is performed with string-match-p.

경기는 string-match-p 로 수행됩니다.

3.8. Use Denote commands from the menu bar or context menu

3.8. 메뉴 표시줄 또는 컨텍스트 메뉴에서 표시 명령 사용

Denote registers a submenu for the menu-bar-mode. Users will find the entry called “Denote”. From there they can use their pointer to select a command. For a sample of how this looks, read the development log: https://protesilaos.com/codelog/2023-03-31-emacs-denote-menu/.

Denote 는 menu-bar-mode 에 대한 하위 메뉴를 등록합니다. 사용자는 "Denote"라는 항목을 찾을 수 있습니다. 여기에서 포인터를 사용하여 명령을 선택할 수 있습니다. 어떻게 보이는지 샘플을 보려면 개발 로그(https://protesilaos.com/codelog/2023-03-31-emacs-denote-menu/)를 참조하세요.

Emacs also provides support for operations through a context menu. This is typically the set of actions that are made available via a right mouse click. Users who enable context-menu-mode can register the Denote entry for it by adding the following to their configuration file:

Emacs 는 상황에 맞는 메뉴를 통한 작업도 지원합니다. 이는 일반적으로 마우스 오른쪽 클릭을 통해 사용할 수 있는 일련의 작업입니다. context-menu-mode 을 활성화한 사용자는 구성 파일에 다음을 추가하여 해당 항목에 대한 Denote 항목을 등록할 수 있습니다:

(add-hook 'context-menu-functions #'denote-context-menu)

4. Renaming files

1. 파일 이름 바꾸기

Denote provides commands to rename files and update their front matter where relevant. For Denote to work, only the file name needs to be in order, by following our naming conventions (). The linking mechanism, in particular, needs just the identifier in the file name ().

Denote 는 파일 이름을 바꾸고 해당되는 경우 앞부분을 업데이트하는 명령을 제공합니다. Denote 가 작동하려면 명명 규칙(파일 명명 체계)에 따라 파일 이름만 순서대로 정렬되어 있으면 됩니다. 특히 링크 메커니즘은 파일 이름에 식별자만 있으면 됩니다( 링크 노트).

We write front matter in notes for the user's convenience and for other tools to make use of that information (e.g. Org's export mechanism). The renaming mechanism takes care to keep this data in sync with the file name, when the user performs a change.

저희는 사용자의 편의와 다른 도구(예: 조직의 내보내기 메커니즘)가 해당 정보를 활용할 수 있도록 앞부분을 노트에 기록합니다. 이름 바꾸기 메커니즘은 사용자가 변경 작업을 수행할 때 이 데이터가 파일 이름과 동기화되도록 관리합니다.

Renaming is useful for managing existing files created with Denote, but also for converting older text files to Denote notes. Denote's file-naming scheme is not specific to notes or text files: it is relevant for all sorts of items, such as multimedia and PDFs that form part of the user's longer-term storage. While Denote does not manage such files (e.g. doesn't create links to them), it already has all the mechanisms to facilitate the task of renaming them.

이름 바꾸기는 Denote 로 만든 기존 파일을 관리할 때 유용할 뿐 아니라, 오래된 텍스트 파일을 Denote 노트로 변환할 때도 유용합니다. Denote 의 파일 이름 바꾸기 체계는 노트나 텍스트 파일에만 국한된 것이 아니라, 사용자의 장기 보관 파일의 일부를 구성하는 멀티미디어와 PDF 등 모든 종류의 항목과 관련이 있습니다. Denote 는 이러한 파일을 관리하지는 않지만(예: 링크를 만들지 않음), 이름 바꾸기 작업을 용이하게 하는 모든 메커니즘을 이미 갖추고 있습니다.

Apart from renaming files, Denote can also rename only the buffer. The idea is that the underlying file name is correct but it can be easier to use shorter buffer names when displaying them on the mode line or switching between then with commands like switch-to-buffer.

파일 이름을 바꾸는 것 외에도 Denote 는 버퍼의 이름만 바꿀 수도 있습니다. 기본 파일 이름은 정확하지만 모드 줄에 표시하거나 switch-to-buffer 와 같은 명령으로 전환할 때 더 짧은 버퍼 이름을 사용하는 것이 더 쉬울 수 있다는 것입니다.

.

버퍼 표시 이름을 자동으로 변경합니다.

4.1. Rename a single file

4.1. 단일 파일 이름 바꾸기

[ Refactored as part of 2.1.0-dev to prompt for a signature (plus other refinements under the hood). ]

[ 2.1.0-dev 의 일부로 서명을 요청하도록 리팩터링되었습니다(기타 내부 개선 사항도 포함). ]

The denote-rename-file command renames a file and updates existing front matter if appropriate. It is possible to do the same with multiple files ().

denote-rename-file 명령은 파일의 이름을 바꾸고 필요한 경우 기존 앞부분을 업데이트합니다. 여러 파일에 대해 동일한 작업을 수행할 수 있습니다(대화형으로 여러 파일 이름 바꾸기).

If in Dired, consider FILE to be the one at point, else prompt with minibuffer completion for one. When called from Lisp, FILE is a filesystem path represented as a string.

Dired 의 경우 FILE 를 지점으로 간주하고, 그렇지 않은 경우 미니버퍼를 완성하라는 메시지를 표시합니다. Lisp 에서 호출할 때 FILE 는 문자열로 표시되는 파일 시스템 경로입니다.

If FILE has a Denote-compliant identifier, retain it while updating the TITLE and KEYWORDS fields of the file name.

FILE 에 Denote 호환 식별자가 있는 경우 파일 이름의 TITLE 및 KEYWORDS 필드를 업데이트하는 동안 해당 식별자를 유지합니다.

Else create an identifier based on the following conditions:

그렇지 않으면 다음 조건에 따라 식별자를 생성합니다:

1. If optional ASK-DATE is non-nil (such as with a prefix argument), prompt for a date and use it to derive the identifier.

   ASK-DATE 옵션이 null 이 아닌 경우(예: 접두사 인수 포함) 날짜를 입력하라는 메시지를 표시하고 이를 사용하여 식별자를 도출합니다.

2. If optional ASK-DATE is nil (this is the case without a prefix argument), use the file attributes to determine the last modified date and format it as an identifier.

   ASK-DATE 옵션이 nil(접두사 인수가 없는 경우)인 경우 파일 속성을 사용하여 마지막으로 수정한 날짜를 확인하고 식별자로 형식을 지정합니다.

3. As a fallback, derive an identifier from the current time.

   대체 수단으로 현재 시간에서 식별자를 도출합니다.

4. If the resulting identifier is not unique among the files in the variable denote-directory, increment it such that it becomes unique.

   결과 식별자가 변수의 파일 중 고유하지 않은 경우 denote-directory , 고유해지도록 식별자를 증가시킵니다.

Use TITLE to construct the new name of FILE. In interactive use, retrieve the default TITLE value from a line starting with a title field in the file's contents, depending on the given file type (). Else, use the file name as a default value at the minibuffer prompt. When called from Lisp, TITLE is a string.

TITLE 를 사용하여 FILE 의 새 이름을 구성합니다. 대화형 사용 시에는 지정된 파일 유형(앞부분)에 따라 파일 내용의 제목 필드로 시작하는 줄에서 기본값 TITLE 값을 검색합니다. 그렇지 않으면 미니 버퍼 프롬프트에서 파일 이름을 기본값으로 사용합니다. Lisp 에서 호출하면 TITLE 은 문자열입니다.

Add SIGNATURE to the file, using an existing one as the default value at the minibuffer prompt. When called from Lisp, SIGNATURE is a string. If the SIGNATURE is empty or nil, it is not included in the new file name.

미니 버퍼 프롬프트에서 기존 파일을 기본값으로 사용하여 파일에 SIGNATURE 을 추가합니다. Lisp 에서 호출할 때 SIGNATURE 은 문자열입니다. SIGNATURE 가 비어 있거나 nil 인 경우 새 파일 이름에 포함되지 않습니다.

As a final step after the FILE, TITLE, KEYWORDS, and SIGNATURE are collected, ask for confirmation, showing the difference between old and new file names. For example:

FILE , TITLE , KEYWORDS , SIGNATURE 을 수집한 후 마지막 단계로 이전 파일 이름과 새 파일 이름의 차이를 표시하여 확인을 요청합니다. 예를 들어

Rename sample.txt to 20220612T052900--my-sample-title__testing.txt? (y or n)

Do not ask for confirmation if the denote-rename-no-confirm option is set to a non-nil value ().

denote-rename-no-confirm 옵션이 nil 이 아닌 값으로 설정된 경우( denote-rename-no-confirm 옵션) 확인을 요청하지 않습니다.

Read the file type extension (like .txt) from the underlying file and preserve it through the renaming process. Files that have no extension are left without one.

기본 파일에서 파일 형식 확장자(예: .txt )를 읽고 이름 바꾸기 프로세스를 통해 보존합니다. 확장자가 없는 파일은 확장자 없이 그대로 유지됩니다.

Renaming only occurs relative to the current directory. Files are not moved between directories.

이름 변경은 현재 디렉터리를 기준으로만 이루어집니다. 파일은 디렉터리 간에 이동되지 않습니다.

If the FILE has Denote-style front matter for the TITLE and KEYWORDS, ask to rewrite their values in order to reflect the new input (this step always requires confirmation and the underlying buffer is not saved, so consider invoking diff-buffer-with-file to double-check the effect). The rewrite of the FILE and KEYWORDS in the front matter should not affect the rest of the front matter.

FILE 에 TITLE 및 KEYWORDS 에 대한 Denote 스타일의 앞부분이 있는 경우 새 입력을 반영하기 위해 해당 값을 다시 작성하도록 요청합니다(이 단계는 항상 확인이 필요하며 기본 버퍼는 저장되지 않으므로 diff-buffer-with-file 을 호출하여 효과를 다시 확인하는 것이 좋습니다). 앞부분의 FILE 및 KEYWORDS 을 다시 작성해도 나머지 앞부분에 영향을 미치지 않아야 합니다.

If the file doesn't have front matter but is among the supported file types (per denote-file-type), add front matter at the top of it and leave the buffer unsaved for further inspection.

파일에 앞부분이 없지만 지원되는 파일 유형( denote-file-type )에 속하는 경우, 파일 상단에 앞부분을 추가하고 추가 검사를 위해 버퍼를 저장하지 않은 채로 둡니다.

For the front matter of each file type, refer to the variables:

각 파일 형식의 앞부분에 있는 변수를 참조하세요:

• denote-org-front-matter
• denote-text-front-matter
• denote-toml-front-matter
• denote-yaml-front-matter

This command is intended to (i) rename existing Denote notes while updating their title and keywords in the front matter, (ii) convert existing supported file types to Denote notes, and (ii) rename non-note files (e.g. PDF) that can benefit from Denote's file-naming scheme. The latter is a convenience we provide, since we already have all the requisite mechanisms in place.

이 명령은 (i) 제목과 앞부분의 키워드를 업데이트하면서 기존 Denote 노트의 이름을 바꾸고, (ii) 기존 지원 파일 형식을 Denote 노트로 변환하고, (ii) Denote 의 파일 명명 체계를 활용할 수 있는 비노트 파일(예: PDF)의 이름을 바꾸기 위해 고안된 것입니다. 후자는 이미 필요한 모든 메커니즘을 갖추고 있기 때문에 저희가 제공하는 편의 기능입니다.

4.1.1. The denote-rename-no-confirm option

4.1.1. denote-rename-no-confirm 옵션

[ Part of 2.1.0-dev. ]

[ 2.1.0 개발 중 일부 ]입니다.

The default behaviour of the denote-rename-file command is to ask for an affirmative answer as a final step before changing the file name and, where relevant, inserting or updating the corresponding front matter ().

denote-rename-file 명령의 기본 동작은 파일 이름을 변경하고 해당되는 경우 해당 앞부분을 삽입하거나 업데이트하기 전에 마지막 단계로 긍정적인 답변을 요청하는 것입니다(단일 파일 이름 바꾸기).

Remember that denote-rename-file does not save the underlying buffer it modifies. It leaves it unsaved so that the user can review what happened, such as by invoking the command diff-buffer-with-file.

denote-rename-file 은 수정한 기본 버퍼를 저장하지 않는다는 점을 기억하세요. 사용자가 diff-buffer-with-file 명령을 실행하는 등 무슨 일이 일어났는지 검토할 수 있도록 저장하지 않은 상태로 둡니다.

Specialised commands that build on top of denote-rename-file may internally bind this user option to a non-nil value in order to perform their operation (e.g. denote-dired-rename-files goes through each marked Dired file, prompting for the information to use, but carries out the renaming without asking for confirmation (buffers remain unsaved)).

denote-rename-file 위에 구축되는 특수 명령은 내부적으로 이 사용자 옵션을 nil 이 아닌 값으로 바인딩하여 작업을 수행할 수 있습니다(예: denote-dired-rename-files 은 Dired 로 표시된 각 파일을 검토하여 사용할 정보를 묻는 메시지를 표시하지만 확인을 요청하지 않고 이름 변경을 수행합니다(버퍼는 저장되지 않은 상태로 유지됨)).

4.2. Rename a single file based on its front matter

4.2. 제목을 기준으로 단일 파일 이름 바꾸기

[ Refactored as part of 2.1.0-dev to not require saving the buffer before renaming it. This means that Denote can now correctly read unsaved file contents. ]

[ 버퍼 이름을 바꾸기 전에 버퍼를 저장할 필요가 없도록 2.1.0-dev 의 일부로 리팩터링되었습니다. 이제 Denote 가 저장되지 않은 파일 내용을 올바르게 읽을 수 있습니다. ]

In the previous section, we covered the more general mechanism of the command denote-rename-file (). There is also a way to have the same outcome by making Denote read the data in the current file's front matter and use it to construct/update the file name. The command for this is denote-rename-file-using-front-matter. It is only relevant for files that (i) are among the supported file types, per denote-file-type, and (ii) have the requisite front matter in place.

이전 섹션에서는 denote-rename-file ( 단일 파일 이름 바꾸기) 명령의 보다 일반적인 메커니즘에 대해 설명했습니다. Denote 가 현재 파일의 앞부분에 있는 데이터를 읽고 이를 사용하여 파일 이름을 작성/업데이트하도록 하여 동일한 결과를 얻을 수 있는 방법도 있습니다. 이를 위한 명령은 denote-rename-file-using-front-matter 입니다. 이 명령은 (i) denote-file-type 에 따라 지원되는 파일 유형에 속하고 (ii) 필수 머리글이 있는 파일에만 해당됩니다.

Suppose you have an .org file with this front matter ():

이 앞부분(Front matter)이 있는 .org 파일이 있다고 가정해 보겠습니다:

#+title:      My sample note file
#+date:       [2022-08-05 Fri 13:10]
#+filetags:   :testing:
#+identifier: 20220805T131044

Its file name reflects this information:

파일 이름에는 이 정보가 반영되어 있습니다:

20220805T131044--my-sample-note-file__testing.org

You want to change its title and keywords manually, so you modify it thus:

제목과 키워드를 수동으로 변경하고 싶으므로 이렇게 수정합니다:

#+title:      My modified sample note file
#+date:       [2022-08-05 Fri 13:10]
#+filetags:   :testing:denote:emacs:
#+identifier: 20220805T131044

At this stage, the file name still shows the old title and keywords. You now invoke denote-rename-file-using-front-matter and it updates the file name to:

이 단계에서는 파일 이름에 여전히 이전 제목과 키워드가 표시됩니다. 이제 denote-rename-file-using-front-matter 을 호출하면 파일 이름이 다음과 같이 업데이트됩니다:

20220805T131044--my-modified-sample-note-file__testing_denote_emacs.org

The renaming is subject to a “yes or no” prompt that shows the old and new names, just so the user is certain about the change.

이름을 변경할 때 이전 이름과 새 이름을 표시하는 "예 또는 아니오" 프롬프트가 표시되므로 사용자가 변경에 대해 확실히 알 수 있습니다.

If called interactively with a prefix argument (C-u by default) or from Lisp with a non-nil AUTO-CONFIRM argument, this “yes or no” prompt is skipped.

접두사 인수(기본적으로 C-u )를 사용하여 대화식으로 호출하거나 nil 이 아닌 AUTO-CONFIRM 인수를 사용하여 Lisp 에서 호출하는 경우 이 "예 또는 아니요" 프롬프트가 건너뛰어집니다.

The identifier of the file, if any, is never modified even if it is edited in the front matter: Denote considers the file name to be the source of truth in this case, to avoid potential breakage with typos and the like.

파일의 식별자가 있는 경우, 앞부분을 수정하더라도 파일 식별자는 수정되지 않습니다: 이 경우 오타 등으로 인한 잠재적 파손을 방지하기 위해 Denote 는 파일 이름을 원본으로 간주합니다.

4.3. Rename multiple files interactively

4.3. 대화형으로 여러 파일 이름 바꾸기

[ Part of 2.1.0-dev. ]

[ 2.1.0 개발 중 일부 ]입니다.

The command denote-dired-rename-files renames the files that are marked in a Dired buffer. Its behaviour is similar to the denote-rename-file in that it prompts for a title, keywords, and signature (). It does so over each marked file, renaming one after the other.

denote-dired-rename-files 명령은 Dired 버퍼에 표시된 파일의 이름을 바꿉니다. 이 명령의 동작은 제목, 키워드 및 서명(단일 파일 이름 바꾸기)을 묻는 메시지를 표시한다는 점에서 denote-rename-file 명령과 유사합니다. 이 명령은 표시된 각 파일에 대해 차례로 이름을 바꿉니다.

Unlike denote-rename-file, the command denote-dired-rename-files does not ask to confirm the changes made to the files: it performs them outright. This is done to make it easier to rename multiple files without having to confirm each step. For an even more direct approach, check the command denote-dired-rename-marked-files:

denote-rename-file 와 달리 denote-dired-rename-files 명령은 파일에 대한 변경 내용을 확인하지 않고 바로 실행합니다. 이는 각 단계를 확인하지 않고도 여러 파일의 이름을 쉽게 바꿀 수 있도록 하기 위한 것입니다. 보다 직접적으로 접근하려면 denote-dired-rename-marked-files 명령을 확인하세요:

• [[#h:f365ff7e-2140-4e14-a92f-666ae97382a4][Rename by writing only keywords

  키워드만 작성하여 이름 바꾸기]]

• [[#h:ea5673cd-e6ca-4c42-a066-07dc6c9d57f8][Rename multiple files based on their front matter

  제목에 따라 여러 파일 이름 바꾸기]]

4.4. Rename multiple files at once by asking only for keywords

4.4. 키워드만 요청하여 한 번에 여러 파일 이름 바꾸기

[ The command denote-dired-rename-marked-files is now called denote-dired-rename-marked-files-with-keywords to better describe what it actually does. To rename multiple Dired marked files while being asked about each file's specifics, use the command denote-dired-rename-files (). This change is done as part of 2.1.0-dev. ]

[ denote-dired-rename-marked-files 명령은 이제 실제로 수행하는 작업을 더 잘 설명하기 위해 denote-dired-rename-marked-files-with-keywords 로 변경되었습니다. 각 파일의 세부 정보를 묻는 메시지가 표시되는 동안 Dired 로 표시된 여러 파일의 이름을 바꾸려면 denote-dired-rename-files (대화형으로 여러 파일 이름 바꾸기) 명령을 사용하세요. 이 변경 사항은 2.1.0-dev 의 일부로 수행되었습니다. ]

The denote-dired-rename-marked-files-with-keywords command renames marked files in Dired to conform with our file-naming scheme. It does so by writing keywords to them. Specifically, it does the following:

denote-dired-rename-marked-files-with-keywords 명령은 Dired 에서 표시된 파일의 이름을 트위터의 파일 이름 지정 체계에 맞게 바꿉니다. 이 명령은 파일에 키워드를 작성하여 이름을 변경합니다. 구체적으로 다음과 같은 작업을 수행합니다:

• retains the file's existing name and makes it the TITLE field, per Denote's file-naming scheme;

  는 파일의 기존 이름을 유지하며 Denote 의 파일 이름 지정 체계에 따라 TITLE 필드로 만듭니다;

• sluggifies the TITLE and adjusts its letter casing, according to our conventions ();

  TITLE 를 슬러그하고 트위터의 규칙(파일 이름의 문자 대소문자 제어)에 따라 문자 대소문자를 조정합니다;

• prepends an identifier to the TITLE, if one is missing;

  에 식별자가 없는 경우 TITLE 에 식별자를 추가합니다;

• preserves the file's extension, if any;

  은 파일의 확장자가 있는 경우 이를 보존합니다;

• prompts once for KEYWORDS and applies the user's input to the corresponding field in the file name, rewriting any keywords that may exist;

  을 입력하라는 메시지를 한 번 표시한 후 KEYWORDS 을 입력하고 파일 이름의 해당 필드에 사용자의 입력을 적용하여 존재할 수 있는 키워드를 다시 작성합니다;

• adds or rewrites existing front matter to the underlying file, if it is recognized as a Denote note (per the denote-file-type user option), such that it includes the new keywords.

  은 ( denote-file-type 사용자 옵션에 따라) Denote 노트로 인식되는 경우, 새로운 키워드를 포함하도록 기존 앞부분을 기본 파일에 추가하거나 다시 작성합니다.

[ Note that the affected buffers are not saved. Users can thus check them to confirm that the new front matter does not cause any problems (e.g. with the diff-buffer-with-file command). Multiple buffers can be saved in one go with save-some-buffers (read its doc string). ]

[ 영향을 받은 버퍼는 저장되지 않습니다. 따라서 사용자는 diff-buffer-with-file 명령으로 새 앞부분이 문제를 일으키지 않는지 확인할 수 있습니다(예: 명령). save-some-buffers (문서 문자열 읽기)를 사용하여 여러 버퍼를 한 번에 저장할 수 있습니다. ]

4.5. Rename multiple files based on their front matter

4.5. 제목을 기준으로 여러 파일 이름 바꾸기

[ Refactored as part of 2.1.0-dev to not require saving the buffer before renaming it. This means that Denote can now correctly read unsaved file contents. Also, the command itself is simplified to be a wrapper of denote-rename-file-using-front-matter for the Dired marked files. ]

[ 버퍼 이름을 바꾸기 전에 버퍼를 저장할 필요가 없도록 2.1.0-dev 의 일부로 리팩터링되었습니다. 즉, 이제 Denote 가 저장되지 않은 파일 내용을 올바르게 읽을 수 있습니다. 또한 명령 자체는 Dired 로 표시된 파일에 대해 denote-rename-file-using-front-matter 의 래퍼로 단순화되었습니다. ]

As already noted, Denote can rename a file based on the data in its front matter (). The command denote-dired-rename-marked-files-using-front-matter extends this principle to a batch operation which applies to all marked files in Dired.

이미 언급했듯이, Denote 는 앞부분의 데이터를 기반으로 파일 이름을 바꿀 수 있습니다(앞부분에 따라 단일 파일 이름 바꾸기). denote-dired-rename-marked-files-using-front-matter 명령은 이 원칙을 Dired 의 모든 표시된 파일에 적용되는 일괄 작업으로 확장합니다.

Marked files must count as notes for the purposes of Denote, which means that they at least have an identifier in their file name and use a supported file type, per denote-file-type. Files that do not meet this criterion are ignored, because Denote cannot know if they have front matter and what that may be. For such files, it is still possible to rename them interactively ().

표시된 파일은 Denote 의 목적상 노트로 간주되어야 하는데, 이는 파일 이름에 최소한 식별자가 있어야 하고 denote-file-type 에 따라 지원되는 파일 형식을 사용해야 함을 의미합니다. 이 기준을 충족하지 않는 파일은 무시되는데, Denote 는 앞부분이 있는지 여부와 그 앞부분이 무엇인지 알 수 없기 때문입니다. 이러한 파일의 경우 대화형으로 파일 이름을 바꿀 수 있습니다(여러 파일 대화형으로 이름 바꾸기).

4.6. Rename a file by changing only its file type

4.6. 파일 유형만 변경하여 파일 이름 바꾸기

[ The command is renamed from denote-change-file-type to denote-change-file-type-and-front-matter as part of 2.1.0-dev because some users thought it was performing full text conversion. ]

[ 일부 사용자가 전체 텍스트 변환을 수행한다고 생각했기 때문에 2.1.0-dev 에서 이 명령의 이름이 denote-change-file-type 에서 denote-change-file-type-and-front-matter 로 변경되었습니다. ]

The command denote-change-file-type-and-front-matter provides the convenience of converting a note taken in one file type, say, .txt into another like .org. It presents a choice among the denote-file-type options.

denote-change-file-type-and-front-matter 명령은 한 파일 형식(예: .txt )으로 작성된 노트를 다른 파일 형식(예: .org )으로 변환하는 편리함을 제공합니다. denote-file-type 옵션 중에서 선택할 수 있습니다.

The conversion does NOT modify the existing front matter. Instead, it prepends new front matter to the top of the file. We do this as a safety precaution since the user can, in principle, add arbitrary extras to their front matter that we would not want to touch.

변환은 기존 앞부분을 수정하지 않습니다. 대신 파일 맨 위에 새로운 머리말을 추가합니다. 이는 원칙적으로 사용자가 임의로 머리말에 우리가 건드리고 싶지 않은 내용을 추가할 수 있기 때문에 안전 예방 조치로 이렇게 합니다.

If in Dired, denote-change-file-type-and-front-matter operates on the file at point, else it prompts with minibuffer completion for one.

Dired 의 경우 denote-change-file-type-and-front-matter 가 해당 파일에 대해 작동하며, 그렇지 않은 경우 미니버퍼를 완료하라는 메시지를 표시합니다.

The title of the file is retrieved from a line starting with a title field in the file's front matter, depending on the previous file type (e.g. #+title for Org). The same process applies for keywords.

파일 제목은 이전 파일 유형에 따라 파일 앞부분의 제목 필드로 시작하는 줄에서 검색됩니다(예: Org 의 경우 #+title ). 키워드에도 동일한 프로세스가 적용됩니다.

As a final step, the command asks for confirmation, showing the difference between old and new file names.

마지막 단계로 명령은 이전 파일 이름과 새 파일 이름의 차이를 표시하여 확인을 요청합니다.

5. The file-naming scheme

파일 이름 지정 체계

Notes are stored in the denote-directory. The default path is ~/Documents/notes. The denote-directory can be a flat listing, meaning that it has no subdirectories, or it can be a directory tree. Either way, Denote takes care to only consider “notes” as valid candidates in the relevant operations and will omit other files or directories.

메모는 denote-directory 에 저장됩니다. 기본 경로는 ~/Documents/notes 입니다. denote-directory 는 하위 디렉터리가 없는 평면 목록일 수도 있고, 디렉토리 트리일 수도 있습니다. 어느 쪽이든, Denote 는 관련 작업에서 "노트"만 유효한 후보로 간주하고 다른 파일이나 디렉터리는 생략합니다.

Every note produced by Denote follows this pattern by default ():

Denote 에서 생성된 모든 노트는 기본적으로 이 패턴을 따릅니다(입력 지점):

DATE--TITLE__KEYWORDS.EXTENSION

The DATE field represents the date in year-month-day format followed by the capital letter T (for “time”) and the current time in hour-minute-second notation. The presentation is compact: 20220531T091625. The DATE serves as the unique identifier of each note and, as such, is also known as the file's ID or identifier.

DATE 필드는 연-월-일 형식의 날짜 뒤에 대문자 T ('시간'의 경우)와 시/분/초 표기로 현재 시간을 나타냅니다. 프레젠테이션은 간결합니다: 20220531T091625 . DATE 는 각 노트의 고유 식별자 역할을 하므로 파일의 ID 또는 식별자라고도 합니다.

The TITLE field is the title of the note, as provided by the user. It automatically gets downcased by default and is also hyphenated (). An entry about “Economics in the Euro Area” produces an economics-in-the-euro-area string for the TITLE of the file name.

TITLE 필드는 사용자가 입력한 노트의 제목입니다. 기본적으로 자동으로 소문자로 바뀌고 하이픈으로 연결됩니다(파일 이름의 문자 대소문자 구분). "유로 지역의 경제학"에 대한 항목은 파일 이름의 TITLE 에 대해 economics-in-the-euro-area 문자열을 생성합니다.

The KEYWORDS field consists of one or more entries demarcated by an underscore (the separator is inserted automatically). Each keyword is a string provided by the user at the relevant prompt which broadly describes the contents of the entry.

KEYWORDS 필드는 밑줄로 구분된 하나 이상의 항목으로 구성됩니다(구분 기호는 자동으로 삽입됨). 각 키워드는 사용자가 관련 프롬프트에서 입력한 문자열로, 항목의 내용을 포괄적으로 설명합니다.

Each of the keywords is a single word, with multiple keywords providing the multi-dimensionality needed for advanced searches through Denote files. Users who need to compose a keyword out of multiple words are encouraged to apply a letter casing convention such as camelCase/CamelCase and set the denote-file-name-letter-casing user option accordingly (). [ The denote-allow-multi-word-keywords is obsolete as part of 2.1.0-dev. ]

각 키워드는 단일 단어이며, 여러 개의 키워드는 Denote 파일을 통한 고급 검색에 필요한 다차원성을 제공합니다. 여러 단어로 키워드를 구성해야 하는 사용자는 대/소문자 구분 규칙을 적용하고 denote-file-name-letter-casing 사용자 옵션을 적절히 설정하는 것이 좋습니다(파일 이름의 대/소문자 구분 제어). [ denote-allow-multi-word-keywords 은 2.1.0-dev 에서 더 이상 사용되지 않습니다.]

The EXTENSION is the file type. By default, it is .org (org-mode) though the user option denote-file-type provides support for Markdown with YAML or TOML variants (.md which runs markdown-mode) and plain text (.txt via text-mode). Consult its doc string for the minutiae. While files end in the .org extension by default, the Denote code base does not actually depend on org.el and/or its accoutrements.

EXTENSION 은 파일 형식입니다. 기본적으로 .org ( org-mode )이지만, 사용자 옵션 denote-file-type 은 YAML 또는 TOML 변형( .md 을 실행하는 markdown-mode )과 일반 텍스트( .txt 를 통해 text-mode )가 포함된 마크다운을 지원합니다. 자세한 내용은 해당 문서 문자열을 참조하세요. 파일은 기본적으로 .org 확장자로 끝나지만, Denote 코드 베이스는 실제로 org.el 및/또는 그 부속 파일에 의존하지 않습니다.

Examples: 예시:

20220610T043241--initial-thoughts-on-the-zettelkasten-method__notetaking.org
20220610T062201--define-custom-org-hyperlink-type__denote_emacs_package.md
20220610T162327--on-hierarchy-and-taxis__notetaking_philosophy.txt

The different field separators, namely -- and __ introduce an efficient way to anchor searches (such as with Emacs commands like isearch or from the command-line with find and related). A query for _word always matches a keyword, while a regexp in the form of, say, "$[0-9T]+?$--$.*?$_" captures the date in group \1 and the title in \2 (test any regular expression in the current buffer by invoking M-x re-builder).

-- 및 __ 같은 다양한 필드 구분 기호는 검색을 효율적으로 고정하는 방법을 소개합니다(예: isearch 같은 Emacs 명령 또는 find 및 관련 명령줄에서). _word 에 대한 쿼리는 항상 키워드와 일치하는 반면, "$[0-9T]+?$--$.*?$_" 형식의 정규식은 그룹 \1 의 날짜와 \2 의 제목을 캡처합니다( M-x re-builder 를 호출하여 현재 버퍼의 정규식을 테스트하세요).

.

검색 또는 필터링을 위한 파일 이름 지정 체계의 기능.

As an optional extension to the above, file names can include a string of alphanumeric characters in the SIGNATURE field. Signatures have no clearly defined purpose and are up to the user to define. One use-case is to use them to establish sequential relations between files (e.g. 1, 1a, 1b, 1b1, 1b2, ...). A full file name with a signature looks like this:

위의 옵션으로 파일 이름에 SIGNATURE 필드에 영숫자 문자열을 포함할 수 있습니다. 서명은 명확하게 정의된 용도가 없으며 사용자가 정의할 수 있습니다. 한 가지 사용 사례는 파일 간의 순차적 관계를 설정하는 데 사용하는 것입니다(예: 1, 1a, 1b, 1b1, 1b2, ...). 서명이 포함된 전체 파일 이름은 다음과 같습니다:

DATE==SIGNATURE--TITLE__KEYWORDS.EXTENSION

The SIGNATURE field is anchored by the equals sign and thus retains the aforementioned searching/anchoring feature of -- and __.

SIGNATURE 필드는 등호로 앵커링되므로 앞서 언급한 -- 및 __ 의 검색/앵커링 기능을 유지합니다.

Signatures are an optional extension to Denote's file-naming scheme. They can be added to newly created files on demand, with the command denote-signature, or by modifying the value of the user option denote-prompts.

서명은 Denote 의 파일 이름 지정 체계에 대한 선택적 확장입니다. 필요에 따라 새로 생성된 파일에 denote-signature 명령을 사용하거나 사용자 옵션 denote-prompts 의 값을 수정하여 추가할 수 있습니다.

The denote-prompts can be configured in such ways to yield the following file name permutations:

denote-prompts 은 다음과 같은 파일 이름 순열을 생성하는 방식으로 구성할 수 있습니다:

DATE.EXT
DATE--TITLE.EXT
DATE__KEYWORDS.EXT
DATE==SIGNATURE.EXT
DATE==SIGNATURE--TITLE.EXT
DATE==SIGNATURE--TITLE__KEYWORDS.EXT
DATE==SIGNATURE__KEYWORDS.EXT

When in doubt, stick to the default design.

확실하지 않은 경우 기본 디자인을 사용하세요.

While Denote is an Emacs package, notes should work long-term and not depend on the functionality of a specific program. The file-naming scheme we apply guarantees that a listing is readable in a variety of contexts. The Denote file-naming scheme is, in essence, an effective, low-tech invention.

Denote 는 Emacs 패키지이지만 노트는 특정 프로그램의 기능에 의존하지 않고 장기적으로 작동해야 합니다. 저희가 적용하는 파일 명명 체계는 다양한 맥락에서 목록을 읽을 수 있도록 보장합니다. Denote 파일 명명 체계는 본질적으로 효과적인 로우테크 발명품입니다.

5.1. Sluggified title, keywords, and signature

5.1. 슬러그 제목, 키워드 및 서명

Denote has to be highly opinionated about which characters can be used in file names and the file's front matter in order to enforce its file-naming scheme. The variable denote-excluded-punctuation-regexp holds the relevant value. In simple terms:

파일 이름 지정 체계를 적용하려면 파일 이름에 사용할 수 있는 문자와 파일 앞부분에 대해 매우 신중하게 결정해야 합니다. denote-excluded-punctuation-regexp 변수는 관련 값을 보유합니다. 간단히 설명하면

• What we count as “illegal characters” are converted into hyphens.

  "불법 문자"로 간주되는 것은 하이픈으로 변환됩니다.

• Input for a file title is hyphenated. The original value is preserved in the note's contents ().

  파일 제목의 입력은 하이픈으로 묶입니다. 원본 값은 노트의 콘텐츠(앞부분)에 보존됩니다.

• Keywords should not have spaces or other delimiters. If they do, they are removed, meaning that hello-world becomes helloworld. This is because hyphens in keywords do not work everywhere, such as in Org.

  키워드에는 공백이나 기타 구분 기호가 없어야 합니다. 공백이 있으면 제거되므로 hello-world 은 helloworld 이 됩니다. 이는 키워드의 하이픈이 Org 와 같은 모든 곳에서 작동하지 않기 때문입니다.

• Signatures are like the above, but use the equals sign instead of hyphens.

  서명은 위와 같지만 하이픈 대신 등호 기호를 사용합니다.

All file name components are downcases by default, though users can configure this behaviour (). Consider a helloWorld or HelloWorld convention for those cases where you would want to have a hyphen between consistuent words of a keyword.

모든 파일 이름 구성 요소는 기본적으로 소문자로 되어 있지만 사용자가 이 동작을 구성할 수 있습니다(파일 이름의 문자 대소문자 제어). 키워드의 일관된 단어 사이에 하이픈을 넣으려는 경우 helloWorld 또는 HelloWorld 규칙을 고려하세요.

5.2. Contol the letter casing of file names

5.2. 파일 이름의 문자 대소문자 제어

[ Part of 2.1.0-dev. ]

[ 2.1.0 개발 중 일부 ]입니다.

The user option denote-file-name-letter-casing controls the letter casing of the individual components of file names (). The default method is to downcase everything.

사용자 옵션 denote-file-name-letter-casing 은 파일 이름의 개별 구성 요소의 문자 대소문자를 제어합니다(파일 이름 지정 체계). 기본 방법은 모든 것을 소문자로 사용하는 것입니다.

The value of this user option is an alist where each element is a cons cell of the form (COMPONENT . METHOD). For example, here is the default value:

이 사용자 옵션의 값은 각 요소가 (COMPONENT . METHOD) 형식의 단점 셀인 목록입니다. 예를 들어 기본값은 다음과 같습니다:

'((title . downcase)
  (signature . downcase)
  (keywords . downcase)
  (t . downcase))

What these cons cells of (COMPONENT . METHOD) are:

(COMPONENT . METHOD) 의 단점은 무엇인가요?

• The COMPONENT is an unquoted symbol among title, signature, keywords, which refer to the corresponding component of the file name. The special t COMPONENT is a fallback value in case the others are not specified.

  COMPONENT 는 파일 이름의 해당 구성 요소를 나타내는 title , signature , keywords 중에서 따옴표로 묶지 않은 기호입니다. 특수 t COMPONENT 는 다른 값이 지정되지 않은 경우를 대비한 대체 값입니다.

• The METHOD is the letter casing scheme, which is an unquoted symbol of either downcase or verbatim. A nil value has the same meaning as downcase. Other non-nil METHOD types are reserved for possible future use.

  METHOD 는 downcase 또는 verbatim 의 따옴표로 묶지 않은 기호인 문자 대소문자 체계입니다. nil 값은 downcase 와 같은 의미를 갖습니다. nil 이 아닌 다른 METHOD 유형은 나중에 사용할 수 있도록 예약되어 있습니다.

  The downcase METHOD converts user input for the given COMPONENT into lower case. The benefit of this approach (which is the default behaviour) is that file names remain consistent over the long-term. The user never needs to account for varying letter casing while working with them.

  downcase METHOD 은 주어진 COMPONENT 에 대한 사용자 입력을 소문자로 변환합니다. 이 접근 방식(기본 동작)의 장점은 파일 이름이 장기간에 걸쳐 일관성을 유지한다는 것입니다. 사용자는 작업하는 동안 다양한 문자 대소문자를 고려할 필요가 없습니다.

  The verbatim METHOD means that Denote will not affect the letter casing of user input when generating the given file name COMPONENT. Conventions like CamelCase or camelCase are respected. The user thus assumes responsibility to keep file names in a good state over the long term.

  verbatim METHOD 은 지정된 파일 이름 COMPONENT 을 생성할 때 Denote 가 사용자 입력의 문자 대소문자에 영향을 주지 않음을 의미합니다. CamelCase 또는 camelCase 와 같은 규칙을 존중합니다. 따라서 사용자는 장기간에 걸쳐 파일 이름을 올바른 상태로 유지할 책임이 있습니다.

As an example, we can downcase the title, but preserve the letter casing of the signature and keyword components with this:

예를 들어 제목의 대소문자를 구분하되 서명 및 키워드 구성 요소의 대소문자는 그대로 유지할 수 있습니다:

(setq denote-file-name-letter-casing
      '((title . downcase)
        (signature . verbatim)
        (keywords . verbatim)
        (t . downcase)))

5.3. Features of the file-naming scheme for searching or filtering

5.3. 검색 또는 필터링을 위한 파일 이름 지정 체계의 특징

By default, file names have three fields and two sets of field delimiters between them:

기본적으로 파일 이름에는 세 개의 필드와 그 사이에 두 세트의 필드 구분 기호가 있습니다:

DATE--TITLE__KEYWORDS.EXTENSION

When a signature is present, this becomes:

서명이 있으면 이렇게 됩니다:

DATE==SIGNATURE--TITLE__KEYWORDS.EXTENSION

Field delimiters practically serve as anchors for easier searching. Consider this example:

필드 구분 기호는 실제로 검색을 쉽게 하기 위한 앵커 역할을 합니다. 이 예제를 살펴보겠습니다:

20220621T062327==1a2--introduction-to-denote__denote_emacs.txt

You will notice that there are two matches for the word denote: one in the title field and another in the keywords' field. Because of the distinct field delimiters, if we search for -denote we only match the first instance while _denote targets the second one. When sorting through your notes, this kind of specificity is invaluable---and you get it for free from the file names alone! Similarly, a search for =1 will show all notes that are related to each other by virtue of their signature.

denote 라는 단어에 대해 제목 필드와 키워드 필드에 두 개의 일치 항목이 있음을 알 수 있습니다. 필드 구분자가 뚜렷하기 때문에 -denote 검색 시 첫 번째 사례만 일치하고 _denote 검색은 두 번째 사례를 대상으로 합니다. 노트를 분류할 때 이러한 특수성은 매우 유용하며, 파일 이름만으로도 무료로 얻을 수 있습니다! 마찬가지로 =1 을 검색하면 서명을 기준으로 서로 연관된 모든 노트가 표시됩니다.

Users can get a lot of value out of this simple yet effective arrangement, even if they have no knowledge of regular expressions. One thing to consider, for maximum effect, is to avoid using multi-word keywords as those can get hyphenated like the title and will thus interfere with the above: either set the user option denote-allow-multi-word-keywords to nil or simply insert single words at the relevant prompts.

사용자는 정규식에 대한 지식이 없더라도 이 간단하면서도 효과적인 배열을 통해 많은 가치를 얻을 수 있습니다. 효과를 극대화하기 위해 고려해야 할 한 가지 사항은 다중 키워드 키워드는 제목처럼 하이픈으로 연결될 수 있으므로 위의 방법을 방해할 수 있으므로 사용자 옵션 denote-allow-multi-word-keywords 을 nil 로 설정하거나 관련 프롬프트에 단일 단어만 삽입하는 것입니다.

6. Front matter

Notes have their own “front matter”. This is a block of data at the top of the file, with no empty lines between the entries, which is automatically generated at the creation of a new note. The front matter includes the title and keywords (aka “tags” or “filetags”, depending on the file type) which the user specified at the relevant prompt, as well as the date and unique identifier, which are derived automatically.

노트에는 고유한 "앞부분"이 있습니다. 이것은 파일 상단에 있는 데이터 블록으로, 항목 사이에 빈 줄이 없으며 새 노트를 만들 때 자동으로 생성됩니다. 머리말에는 사용자가 관련 프롬프트에서 지정한 제목과 키워드(파일 유형에 따라 "태그" 또는 "파일태그"라고도 함)는 물론, 자동으로 생성되는 날짜와 고유 식별자가 포함됩니다.

This is how it looks for Org mode (when denote-file-type is nil or the org symbol):

조직 모드의 경우 다음과 같이 표시됩니다( denote-file-type 가 0 이거나 org 기호인 경우):

#+title:      This is a sample note
#+date:       [2022-06-30 Thu 16:09]
#+filetags:   :denote:testing:
#+identifier: 20220630T160934

For Markdown with YAML (denote-file-type has the markdown-yaml value), the front matter looks like this:

YAML 을 사용한 마크다운( denote-file-type 값은 markdown-yaml )의 경우 앞부분은 다음과 같이 표시됩니다:

---
title:      "This is a sample note"
date:       2022-06-30T16:09:58+03:00
tags:       ["denote", "testing"]
identifier: "20220630T160958"
---

For Markdown with TOML (denote-file-type has the markdown-toml value), it is:

TOML 을 사용한 마크다운( denote-file-type 값은 markdown-toml )의 경우, 그렇습니다:

+++
title      = "This is a sample note"
date       = 2022-06-30T16:10:13+03:00
tags       = ["denote", "testing"]
identifier = "20220630T161013"
+++

And for plain text (denote-file-type has the text value), we have the following:

일반 텍스트( denote-file-type 값은 text )의 경우 다음과 같습니다:

title:      This is a sample note
date:       2022-06-30
tags:       denote  testing
identifier: 20220630T161028
---------------------------

The format of the date in the front matter is controlled by the user option denote-date-format. When nil, Denote uses a file-type-specific format:

앞부분의 날짜 형식은 사용자 옵션 denote-date-format 에 의해 제어됩니다. nil 인 경우, Denote 는 파일 유형별 형식을 사용합니다:

• For Org, an inactive timestamp is used, such as [2022-06-30 Wed 15:31].

  Org 의 경우 [2022-06-30 Wed 15:31] 와 같은 비활성 타임스탬프가 사용됩니다.

• For Markdown, the RFC3339 standard is applied: 2022-06-30T15:48:00+03:00.

  마크다운의 경우 RFC3339 표준이 적용됩니다: 2022-06-30T15:48:00+03:00 .

• For plain text, the format is that of ISO 8601: 2022-06-30.

  일반 텍스트의 경우 ISO 8601 형식( 2022-06-30 )을 사용합니다.

If the value is a string, ignore the above and use it instead. The string must include format specifiers for the date. These are described in the doc string of format-time-string..

값이 문자열인 경우 위의 내용을 무시하고 대신 사용합니다. 문자열에는 날짜에 대한 형식 지정자가 포함되어야 합니다. 이는 format-time-string ...의 문서 문자열에 설명되어 있습니다.

6.1. Change the front matter format : 머리말 형식 변경

Per Denote's design principles, the code is hackable. All front matter is stored in variables that are intended for public use. We do not declare those as “user options” because (i) they expect the user to have some degree of knowledge in Emacs Lisp and (ii) implement custom code.

Denote 의 설계 원칙에 따라 코드는 해킹이 가능합니다. 모든 앞부분은 공개용으로 의도된 변수에 저장됩니다. 이러한 변수를 '사용자 옵션'으로 선언하지 않는 이유는 (i) 사용자가 Emacs Lisp 에 대해 어느 정도 지식이 있을 것으로 예상하고 (ii) 사용자 지정 코드를 구현하기 때문입니다.

[ NOTE for tinkerers: code intended for internal use includes double hyphens in its symbol. “Internal use” means that it can be changed without warning and with no further reference in the change log. Do not use any of it without understanding the consequences. ]

[땜장이를 위한 참고 사항: 내부 사용용 코드는 기호에 이중 하이픈이 포함되어 있습니다. "내부 사용"이란 경고 없이 변경 로그에 추가 참조 없이 변경할 수 있음을 의미합니다. 그 결과를 이해하지 않고 사용하지 마세요. ]

The variables which hold the front matter format are:

앞부분 형식을 유지하는 변수는 다음과 같습니다:

• denote-org-front-matter

• denote-text-front-matter

• denote-toml-front-matter

• denote-yaml-front-matter

These variables have a string value with specifiers that are used by the format function. The formatting operation passes four arguments which include the values of the given entries. If you are an advanced user who wants to edit this variable to affect how front matter is produced, consider using something like %2$s to control where the Nth argument is placed.

이러한 변수에는 format 함수에서 사용하는 지정자가 있는 문자열 값이 있습니다. 서식 지정 작업은 지정된 항목의 값을 포함하는 네 개의 인수를 전달합니다. 이 변수를 편집하여 앞부분이 생성되는 방식에 영향을 주고자 하는 고급 사용자라면 %2$s 같은 것을 사용하여 N 번째 인수가 배치되는 위치를 제어하는 것이 좋습니다.

When editing the value, make sure to:

값을 편집할 때는 반드시 이렇게 하세요:

1. Not use empty lines inside the front matter block.

   제목 블록 내부에 빈 줄을 사용하지 마세요.

2. Insert at least one empty line after the front matter block and do not use any empty line before it.

   제목 블록 뒤에 빈 줄을 하나 이상 삽입하고 그 앞에는 빈 줄을 사용하지 마세요.

These help with consistency and might prove useful if we ever need to operate on the front matter as a whole.

이는 일관성을 유지하는 데 도움이 되며, 전반적으로 문제를 처리해야 할 때 유용하게 사용될 수 있습니다.

With those granted, below are some examples. The approach is the same for all variables.

이러한 권한이 부여된 상태에서 다음은 몇 가지 예입니다. 접근 방식은 모든 변수에 대해 동일합니다.

;; Like the default, but upcase the entries
(setq denote-org-front-matter
  "#+TITLE:      %s
#+DATE:       %s
#+FILETAGS:   %s
#+IDENTIFIER: %s
\n")
 
;; Change the order (notice the %N$s notation)
(setq denote-org-front-matter
  "#+title:      %1$s
#+filetags:   %3$s
#+date:       %2$s
#+identifier: %4$s
\n")
 
;; Remove the date
(setq denote-org-front-matter
  "#+title:      %1$s
#+filetags:   %3$s
#+identifier: %4$s
\n")
 
;; Remove the date and the identifier
(setq denote-org-front-matter
  "#+title:      %1$s
#+filetags:   %3$s
\n")

Note that setq has a global effect: it affects the creation of all new notes. Depending on the workflow, it may be preferrable to have a custom command which let binds the different format. We shall not provide examples at this point as this is a more advanced feature and we are not yet sure what the user's needs are. Please provide feedback and we shall act accordingly.

setq 은 모든 새 노트 생성에 영향을 미치므로 전역적으로 적용된다는 점에 유의하세요. 워크플로우에 따라, let 이 다른 형식을 바인딩하는 사용자 지정 명령을 사용하는 것이 더 바람직할 수 있습니다. 이 기능은 고급 기능이고 사용자의 요구가 무엇인지 아직 확실하지 않기 때문에 현재로서는 예시를 제공하지 않습니다. 피드백을 제공해 주시면 그에 따라 조치를 취하겠습니다.

6.2. Regenerate front matter

Sometimes the user needs to produce new front matter for an existing note. Perhaps because they accidentally deleted a line and could not undo the operation. The command denote-add-front-matter can be used for this very purpose.

사용자가 기존 노트의 앞부분을 새로 작성해야 하는 경우가 있습니다. 실수로 한 줄을 삭제해 작업을 되돌릴 수 없기 때문일 수도 있습니다. denote-add-front-matter 명령은 바로 이런 용도로 사용할 수 있습니다.

In interactive use, denote-add-front-matter must be invoked from a buffer that visits a Denote note. It prompts for a title and then for keywords. These are the standard prompts we already use for note creation, so the keywords' prompt allows minibuffer completion and the input of multiple entries, each separated by a comma ().

대화형 사용 시, denote-add-front-matter 은 Denote 노트를 방문하는 버퍼에서 호출되어야 합니다. 제목을 입력한 다음 키워드를 입력하라는 메시지가 표시됩니다. 이 프롬프트는 노트 작성에 이미 사용하고 있는 표준 프롬프트이므로, 키워드 프롬프트를 통해 미니버퍼를 완성하고 쉼표로 구분된 여러 항목을 입력할 수 있습니다(입력 지점).

The newly created front matter is added to the top of the file.

새로 생성된 앞부분이 파일 상단에 추가됩니다.

This command does not rename the file (e.g. to update the keywords). To rename a file by reading its front matter as input, the user can rely on denote-rename-file-using-front-matter ().

이 명령은 파일 이름을 바꾸지 않습니다(예: 키워드 업데이트). 파일의 앞부분을 입력으로 읽어 파일 이름을 바꾸려면 denote-rename-file-using-front-matter ( 파일 이름 바꾸기)를 사용하면 됩니다.

Note that denote-add-front-matter is useful only for existing Denote notes. If the user needs to convert a generic text file to a Denote note, they can use one of the command which first rename the file to make it comply with our file-naming scheme and then add the relevant front matter.

denote-add-front-matter 은 기존 Denote 노트에만 유용합니다. 사용자가 일반 텍스트 파일을 Denote 노트로 변환해야 하는 경우, 먼저 파일 이름 지정 체계에 맞게 파일 이름을 바꾼 다음 관련 앞부분을 추가하는 명령 중 하나를 사용하면 됩니다.

7. Linking notes

Denote 는 노트 사이를 연결하기 위한 몇 가지 명령을 제공합니다.

모든 링크는 Denote 노트인 파일을 대상으로 합니다. 즉, 파일 명명 체계가 있고, 쓰기 가능/일반 파일(디렉토리, 명명된 파이프 등이 아님)이며, 적절한 파일 형식 확장자( denote-file-type 에 따름)를 사용해야 합니다. 또한, 파일은 denote-directory 또는 그 하위 디렉터리 중 하나에 있어야 합니다. 다른 파일은 인식되지 않습니다.

다음 섹션에서는 자세한 내용을 살펴봅니다.

7.1. Adding a single link

단일 링크 추가하기

The denote-link command inserts a link at point to a file specified at the minibuffer prompt. Links are formatted depending on the file type of the current note. In Org and plain text buffers, links are formatted thus: [[id:IDENTIFIER][TITLE]]. While in Markdown they are expressed as [TITLE](denote:IDENTIFIER).

denote-link 명령은 미니버퍼 프롬프트에서 지정한 파일 지점에 링크를 삽입합니다. 링크는 현재 노트의 파일 유형에 따라 서식이 지정됩니다. 조직과 일반 텍스트 버퍼에서는 링크의 서식이 다음과 같이 지정됩니다: [[id:IDENTIFIER][TITLE]] . 마크다운에서는 [TITLE](denote:IDENTIFIER) 로 표현됩니다.

When denote-link is called with a prefix argument (C-u by default), it formats links like [[id:IDENTIFIER]]. The user might prefer its simplicity.

denote-link 가 접두사 인수(기본값은 C-u )와 함께 호출되면 [[id:IDENTIFIER]] 와 같은 링크 형식이 지정됩니다. 사용자는 단순함을 선호할 수 있습니다.

The description of the link is taken from the target file's front matter or, if that is not available, from the file name. If the region is active, its text is used as the link's description instead. If the active region has no text, the inserted link uses just the identifier, as with the C-u prefix mentioned above.

링크에 대한 설명은 대상 파일의 머리글에서 가져 오거나 사용할 수 없는 경우 파일 이름에서 가져옵니다. 영역이 활성화되어 있으면 해당 텍스트가 링크 설명으로 사용됩니다. 활성 영역에 텍스트가 없는 경우 삽입된 링크는 위에서 언급한 C-u 접두사와 같이 식별자만 사용합니다.

[ For more advanced uses, refer to the doc string of the denote-link function. The denote-link gained new arguments as part of 2.1.0-dev. ]

[ 더 고급 용도로 사용하려면 denote-link 함수의 문서 문자열을 참조하세요. denote-link 함수는 2.1.0-dev 의 일부로 새로운 인수를 얻었습니다. ]

Inserted links are automatically buttonized and remain active for as long as the buffer is available. In Org this is handled by the major mode: the denote: hyperlink type works exactly like the standard file:. In Markdown and plain text, Denote performs the buttonization of those links. To buttonize links in existing files while visiting them, the user must add this snippet to their setup (it already excludes Org):

삽입된 링크는 자동으로 버튼화되며 버퍼를 사용할 수 있는 한 활성 상태로 유지됩니다. Org 에서는 denote: 하이퍼링크 유형이 표준 file: 과 똑같이 작동하는 주 모드로 처리됩니다. 마크다운과 일반 텍스트에서는 Denote 가 해당 링크의 버튼화를 수행합니다. 기존 파일을 방문하는 동안 기존 파일의 링크를 버튼화하려면 사용자가 이 스니펫을 설정에 추가해야 합니다(이미 Org 는 제외됨):

(add-hook 'find-file-hook #'denote-link-buttonize-buffer)

The denote-link-buttonize-buffer is also an interactive function in case the user needs it.

denote-link-buttonize-buffer 은 사용자가 필요로 하는 경우 대화형 기능도 제공합니다.

Links are created only for files which qualify as a “note” for our purposes ().

링크는 당사 목적상 '노트'로 인정되는 파일에 대해서만 생성됩니다('노트 연결').

Links are styled with the denote-faces-link face, which looks exactly like an ordinary link by default. This is just a convenience for the user/theme in case they want denote: links to remain distinct from other links.

링크는 기본적으로 일반 링크와 똑같이 보이는 denote-faces-link 얼굴로 스타일이 지정됩니다. 이는 denote: 링크가 다른 링크와 구분되도록 하려는 사용자/테마의 편의를 위한 것입니다.

7.2. Insert links matching a regexp

7.2. 정규식과 일치하는 링크 삽입하기

The command denote-add-links adds links at point matching a regular expression or plain string. The links are inserted as a typographic list, such as:

denote-add-links 명령은 정규식 또는 일반 문자열과 일치하는 지점에 링크를 추가합니다. 링크는 다음과 같은 타이포그래피 목록으로 삽입됩니다:

- link1
- link2
- link3

Each link is formatted according to the file type of the current note, as explained further above about the denote-link command. The current note is excluded from the matching entries (adding a link to itself is pointless).

각 링크는 denote-link 명령에 대해 위에서 설명한 대로 현재 노트의 파일 형식에 따라 서식이 지정됩니다. 현재 노트는 일치하는 항목에서 제외됩니다(노트 자체에 링크를 추가하는 것은 의미가 없음).

When called with a prefix argument (C-u) denote-add-links will format all links as [[id:IDENTIFIER]], hence a typographic list:

접두사 인수( C-u )와 함께 호출하면 denote-add-links 은 모든 링크의 형식을 [[id:IDENTIFIER]] 으로 지정하므로 타이포그래피 목록이 됩니다:

- [[id:IDENTIFIER-1]]
- [[id:IDENTIFIER-2]]
- [[id:IDENTIFIER-3]]

Same examples of a regular expression that can be used with this command:

이 명령과 함께 사용할 수 있는 정규식의 예는 다음과 같습니다:

• journal match all files which include journal anywhere in their name.

  journal 파일 이름에 journal 가 포함된 모든 파일을 일치시킵니다.

• _journal match all files which include journal as a keyword.

  _journal journal 을 키워드로 포함하는 모든 파일을 일치시킵니다.

• ^2022.*_journal match all file names starting with 2022 and including the keyword journal.

  ^2022.*_journal 2022 로 시작하고 journal 키워드를 포함한 모든 파일 이름을 일치시킵니다.

• \.txt match all files including .txt. In practical terms, this only applies to the file extension, as Denote automatically removes dots (and other characters) from the base file name.

  \.txt 를 포함한 모든 파일을 일치시킵니다 .txt . 실제로는 파일 확장자에만 적용되는데, Denote 는 기본 파일 이름에서 점(및 기타 문자)을 자동으로 제거하기 때문입니다.

If files are created with denote-sort-keywords as non-nil (the default), then it is easy to write a regexp that includes multiple keywords in alphabetic order:

denote-sort-keywords (기본값)이 아닌 nil 로 파일을 만들면 여러 키워드를 알파벳 순서로 포함하는 정규식을 쉽게 작성할 수 있습니다:

• _denote.*_package match all files that include both the denote and package keywords, in this order.

  _denote.*_package denote 및 package 키워드가 모두 포함된 모든 파일을 이 순서대로 일치시킵니다.

• \(.*denote.*package.*\)\|\(.*package.*denote.*\) is the same as above, but out-of-order.

  \(.*denote.*package.*\)\|\(.*package.*denote.*\) 는 위와 동일하지만 순서가 잘못되었습니다.

Remember that regexp constructs only need to be escaped once (like \|) when done interactively but twice when called from Lisp. What we show above is for interactive usage.

정규식 구문은 대화형일 때는 한 번만 이스케이프하면 되지만(예: \| ), Lisp 에서 호출할 때는 두 번만 이스케이프하면 된다는 점을 기억하세요. 위에 표시된 것은 대화형 사용을 위한 것입니다.

Links are created only for files which qualify as a “note” for our purposes ().

링크는 당사 목적상 '노트'로 인정되는 파일에 대해서만 생성됩니다('노트 연결').

7.3. Insert link to file with signature

7.3. 서명이 있는 파일 링크 삽입

[ Part of 2.1.0-dev. ]

[ 2.1.0 개발 중 일부 ]입니다.

The command denote-link-with-signature prompts for a file among those that contain a ==SIGNATURE and inserts a link to it. The description of the link includes the text of the signature and that of the file's title, if any. For example, a link to the following file:

denote-link-with-signature 명령은 ==SIGNATURE 이 포함된 파일 중에서 파일을 찾고 해당 파일에 대한 링크를 삽입하는 메시지를 표시합니다. 링크 설명에는 서명의 텍스트와 파일 제목(있는 경우)의 텍스트가 포함됩니다. 예를 들어 다음 파일에 대한 링크입니다:

20230925T144303==abc--my-first-signature-note__denote_testing.txt

will get this link: [[denote:20230925T144303][abc My first signature note]].

이 링크를 받게 됩니다: [[denote:20230925T144303][abc My first signature note]] .

For more advanced uses, refer to the doc string of the denote-link function.

고급 사용법은 denote-link 함수의 문서 문자열을 참조하세요.

7.4. Insert links, but only those missing from current buffer

7.4. 현재 버퍼에서 누락된 링크만 삽입하기

As a variation on the denote-add-links command, one may wish to only include 'missing links', i.e. links that are not yet present in the current file.

denote-add-links 명령의 변형으로 '누락된 링크', 즉 현재 파일에 아직 존재하지 않는 링크만 포함할 수 있습니다.

This can be achieved with denote-add-missing-links. The command is similar to denote-add-links, but will only include links to notes that are not yet linked to ().

denote-add-missing-links 로 가능합니다. 이 명령은 denote-add-links 와 유사하지만 아직 링크되지 않은 노트에 대한 링크만 포함합니다( 정규식과 일치하는 링크 삽입).

7.5. Insert links from marked files in Dired

7.5. Dired 에 표시된 파일에서 링크 삽입

The command denote-link-dired-marked-notes is similar to denote-add-links in that it inserts in the buffer a typographic list of links to Denote notes (). Though instead of reading a regular expression, it lets the user mark files in Dired and link to them. This should be easier for users of all skill levels, instead of having to write a potentially complex regular expression.

denote-link-dired-marked-notes 명령은 버퍼에 링크의 타이포그래피 목록을 삽입한다는 점에서 denote-add-links 명령과 유사합니다('정규식과 일치하는 링크 삽입'). 하지만 정규식을 읽는 대신 사용자가 Dired 에서 파일을 표시하고 링크할 수 있습니다. 잠재적으로 복잡한 정규식을 작성할 필요 없이 모든 기술 수준의 사용자가 더 쉽게 사용할 수 있습니다.

If there are multiple buffers that visit a Denote note, this command will ask to select one among them, using minibuffer completion. If there is only one buffer, it will operate in it outright. If there are no buffers, it will produce an error.

Denote 노트를 방문하는 버퍼가 여러 개 있는 경우, 이 명령은 미니버퍼 완성을 사용해 그 중 하나를 선택하라는 메시지를 표시합니다. 버퍼가 하나만 있는 경우, 그 버퍼에서 바로 작동합니다. 버퍼가 없으면 오류가 발생합니다.

With optional ID-ONLY as a prefix argument (C-u by default), the command inserts links with just the identifier, which is the same principle as with denote-link and others ().

접두사 인수로 ID-ONLY (기본값은 C-u )를 선택적으로 사용하면 이 명령은 denote-link 및 기타(단일 링크 추가)와 동일한 원리로 식별자만 있는 링크를 삽입합니다.

The command denote-link-dired-marked-notes is meant to be used from a Dired buffer.

denote-link-dired-marked-notes 명령은 Dired 버퍼에서 사용하도록 되어 있습니다.

As always, links are created only for files which qualify as a “note” for our purposes ().

항상 그렇듯이 링크는 당사 목적상 '노트'로 인정되는 파일에 대해서만 생성됩니다('노트 연결').

7.6. Link to an existing note or create a new one

7.6. 기존 노트에 링크하거나 새 노트 만들기

In one's note-taking workflow, there may come a point where they are expounding on a certain topic but have an idea about another subject they would like to link to (). The user can always rely on the other linking facilities we have covered herein to target files that already exist. Though they may not know whether they already have notes covering the subject or whether they would need to write new ones. To this end, Denote provides two convenience commands:

노트 필기 워크플로우에서 특정 주제에 대해 설명하다가 링크하고 싶은 다른 주제에 대한 아이디어가 떠오를 때가 있을 수 있습니다(노트 연결). 사용자는 여기서 다룬 다른 링크 기능을 사용해 이미 존재하는 파일을 대상으로 삼을 수 있습니다. 하지만 이미 해당 주제를 다루는 노트가 있는지, 아니면 새 노트를 작성해야 하는지 알 수 없을 수도 있습니다. 이를 위해 Denote 는 두 가지 편리한 명령을 제공합니다:

denote-link-after-creating : Create new note in the background and link to it directly.

백그라운드에서 새 노트를 만들고 바로 링크하세요.

Use `denote` interactively to produce the new note. Its doc string or this manual explains which prompts will be used and under what conditions ().

`denote` 대화식으로 새 노트를 만듭니다. 해당 문서 문자열 또는 이 설명서에 어떤 프롬프트가 어떤 조건에서 사용되는지 설명되어 있습니다(표준 노트 만들기).

With optional `ID-ONLY` as a prefix argument (this is the `C-u` key, by default) create a link that consists of just the identifier. Else try to also include the file's title. This has the same meaning as in `denote-link` ().

선택 사항으로 `ID-ONLY` 를 접두사 인수로 사용하여(기본값은 `C-u` 키) 식별자만으로 구성된 링크를 만듭니다. 그렇지 않으면 파일 제목도 포함하세요. 이는 `denote-link` (단일 링크 추가)에서와 동일한 의미를 갖습니다.

IMPORTANT NOTE: Normally, `denote` does not save the buffer it produces for the new note. This is a safety precaution to not write to disk unless the user wants it (e.g. the user may choose to kill the buffer, thus cancelling the creation of the note). However, for this command the creation of the note happens in the background and the user may miss the step of saving their buffer. We thus have to save the buffer in order to (i) establish valid links, and (ii) retrieve whatever front matter from the target file.

중요 참고: 일반적으로 `denote` 은 새 노트에 대해 생성한 버퍼를 저장하지 않습니다. 이는 사용자가 원하지 않는 한 디스크에 쓰지 않기 위한 안전 예방 조치입니다(예: 사용자가 버퍼를 삭제해 노트 생성을 취소할 수 있음). 하지만 이 명령의 경우, 노트 생성이 백그라운드에서 이루어지기 때문에 사용자가 버퍼 저장 단계를 놓칠 수 있습니다. 따라서 (1) 유효한 링크를 설정하고 (2) 대상 파일에서 앞부분을 검색하려면 버퍼를 저장해야 합니다.

denote-link-after-creating-with-command : This command is like denote-link-after-creating except it prompts for a note-creating command (). Use this to, for example, call denote-signature so that the newly created note has a signature as part of its file name. Optional ID-ONLY has the same meaning as in the command denote-link-after-creating.

이 명령은 `denote-link-after-creating` 와 같지만 노트 만들기 명령(입력 지점)을 묻는 메시지가 뜬다는 점이 다릅니다. 예를 들어, `denote-signature` 을 호출해 새로 만든 노트의 파일 이름에 서명이 포함되도록 할 수 있습니다. `ID-ONLY` 옵션은 `denote-link-after-creating` 명령과 같은 의미를 갖습니다.

denote-link-or-create : Use denote-link on TARGET file, creating it if necessary.

`TARGET` 파일에 `denote-link` 을 사용하여 필요한 경우 생성합니다.

If `TARGET` file does not exist, call `denote-link-after-creating` which runs the `denote` command interactively to create the file. The established link will then be targeting that new file.

`TARGET` 파일이 없는 경우 `denote-link-after-creating` 을 호출하여 `denote` 명령을 대화형으로 실행하여 파일을 생성합니다. 그러면 설정된 링크가 해당 새 파일을 대상으로 합니다.

If `TARGET` file does not exist, add the user input that was used to search for it to the history of the `denote-file-prompt`. The user can then retrieve and possibly further edit their last input, using it as the newly created note's actual title. At the `denote-file-prompt` type `M-p` with the default key bindings, which calls `previous-history-element`.

`TARGET` 파일이 존재하지 않는 경우, 검색에 사용된 사용자 입력을 `denote-file-prompt` 의 히스토리에 추가합니다. 그러면 사용자는 마지막 입력을 검색하고 추가로 편집해 새로 만든 노트의 실제 제목으로 사용할 수 있습니다. `denote-file-prompt` 에서 기본 키 바인딩으로 `M-p` 을 입력하면 `previous-history-element` 이 호출됩니다.

With optional `ID-ONLY` as a prefix argument create a link with just the file's identifier. This has the same meaning as in `denote-link`.

선택 사항으로 `ID-ONLY` 를 접두사 인수로 사용하여 파일 식별자만 포함된 링크를 만듭니다. 이는 `denote-link` 에서와 같은 의미입니다.

This command has the alias `denote-link-to-existing-or-new-note`, which helps with discoverability.

이 명령에는 검색 가능성을 높이는 별칭 `denote-link-to-existing-or-new-note` 이 있습니다.

7.7. The backlinks' buffer

7.7. 백링크의 버퍼

The command denote-backlinks produces a bespoke buffer which displays backlinks to the current note. A “backlink” is a link back to the present entry.

denote-backlinks 명령은 현재 노트의 백링크를 표시하는 맞춤형 버퍼를 생성합니다. "백링크"는 현재 항목으로 돌아가는 링크입니다.

By default, the backlinks' buffer is designed to display the file name of the note linking to the current entry. Each file name is presented on its own line, like this:

기본적으로 백링크의 버퍼는 현재 항목으로 연결되는 노트의 파일 이름을 표시하도록 설계되어 있습니다. 각 파일 이름은 다음과 같이 자체 줄에 표시됩니다:

Backlinks to "On being honest" (20220614T130812)
------------------------------------------------
 
20220614T145606--let-this-glance-become-a-stare__journal.txt
20220616T182958--feeling-butterflies-in-your-stomach__journal.txt

When the user option denote-backlinks-show-context is non-nil, the backlinks' buffer displays the line on which a link to the current note occurs. It also shows multiple occurrences, if present. It looks like this (and has the appropriate fontification):

사용자 옵션 denote-backlinks-show-context 이 0 이 아닌 경우, 백링크의 버퍼에는 현재 노트에 대한 링크가 발생한 줄이 표시됩니다. 링크가 여러 개 있는 경우, 여러 개를 표시하기도 합니다. 다음과 같이 표시됩니다(적절한 글꼴이 적용됨):

Backlinks to "On being honest" (20220614T130812)
------------------------------------------------
 
20220614T145606--let-this-glance-become-a-stare__journal.txt
37: growing into it: [[denote:20220614T130812][On being honest]].
64: As I said in [[denote:20220614T130812][On being honest]] I have never
20220616T182958--feeling-butterflies-in-your-stomach__journal.txt
62: indifference.  In [[denote:20220614T130812][On being honest]] I alluded

Note that the width of the lines in the context depends on the underlying file. In the above example, the lines are split at the fill-column. Long lines will show up just fine. Also note that the built-in user option xref-truncation-width can truncate long lines to a given maximum number of characters.

컨텍스트에서 선의 너비는 기본 파일에 따라 달라집니다. 위의 예에서 줄은 fill-column 에서 분할됩니다. 긴 줄도 정상적으로 표시됩니다. 또한 기본 제공 사용자 옵션 xref-truncation-width 은 긴 줄을 지정된 최대 글자 수로 잘라낼 수 있습니다.

[[#h:893eec49-d7be-4603-bcff-fcc247244011][Speed up backlinks' buffer creation?

백링크의 버퍼 생성 속도를 높이시겠습니까?]]

The backlinks' buffer runs the major-mode denote-backlinks-mode. It binds keys to move between links with n (next) and p (previous). These are stored in the denote-backlinks-mode-map (use M-x describe-mode (C-h m) in an unfamiliar buffer to learn more about it). When the user option denote-backlinks-show-context is non-nil, all relevant Xref key bindings are fully functional: again, check describe-mode.

백링크의 버퍼는 메이저 모드 denote-backlinks-mode 를 실행합니다. n (다음) 및 p (이전)으로 링크 사이를 이동하는 키를 바인딩합니다. 이러한 키는 denote-backlinks-mode-map 에 저장됩니다(익숙하지 않은 버퍼에서는 M-x describe-mode ( C-h m )를 참조하세요). 사용자 옵션 denote-backlinks-show-context 이 nil 이 아닌 경우 모든 관련 Xref 키 바인딩이 완전히 작동합니다: describe-mode 을 다시 확인하세요.

The backlinking facility uses Emacs' built-in Xref infrastructure. On some operating systems, the user may need to add certain executables to the relevant environment variable.

백링크 기능은 Emacs 에 내장된 Xref 인프라를 사용합니다. 일부 운영 체제에서는 사용자가 관련 환경 변수에 특정 실행 파일을 추가해야 할 수 있습니다.

[[#h:42f6b07e-5956-469a-8294-17f9cf62eb2b][Why do I get “Search failed with status 1” when I search for backlinks?

백링크를 검색할 때 '상태 1 로 검색 실패'라는 메시지가 표시되는 이유는 무엇인가요?]]

Backlinks to the current file can also be visited by using the minibuffer completion interface with the denote-find-backlink command ().

현재 파일에 대한 백링크는 미니버퍼 완성 인터페이스를 사용하여 denote-find-backlink 명령(미니버퍼를 통해 링크된 파일 방문하기)으로도 방문할 수 있습니다.

The placement of the backlinks' buffer is subject to the user option denote-link-backlinks-display-buffer-action. Due to the nature of the underlying display-buffer mechanism, this inevitably is a relatively advanced feature. By default, the backlinks' buffer is displayed below the current window. The doc string of our user option includes a sample configuration that places the buffer in a left side window instead. Reproducing it here for the sake of convenience:

백링크 버퍼의 위치는 사용자 옵션 denote-link-backlinks-display-buffer-action 에 따라 달라집니다. 기본 display-buffer 메커니즘의 특성으로 인해 이는 상대적으로 고급 기능일 수밖에 없습니다. 기본적으로 백링크의 버퍼는 현재 창 아래에 표시됩니다. 사용자 옵션의 문서 문자열에는 버퍼를 왼쪽 창에 배치하는 샘플 구성이 포함되어 있습니다. 편의를 위해 여기에 재현해 보았습니다:

(setq denote-link-backlinks-display-buffer-action
      '((display-buffer-reuse-window
         display-buffer-in-side-window)
        (side . left)
        (slot . 99)
        (window-width . 0.3)))

7.8. Writing metanotes

메타노트 작성

A “metanote” is an entry that describes other entries who have something in common. Writing metanotes can be part of a workflow where the user periodically reviews their work in search of patterns and deeper insights. For example, you might want to read your journal entries from the past year to reflect on your experiences, evolution as a person, and the like.

"메타노트"는 공통점이 있는 다른 항목에 대해 설명하는 항목입니다. 메타노트를 작성하는 것은 사용자가 패턴과 더 깊은 통찰력을 찾기 위해 주기적으로 작업을 검토하는 워크플로우의 일부가 될 수 있습니다. 예를 들어, 지난 한 해 동안의 일기 항목을 읽으며 자신의 경험, 한 사람으로서의 발전 등을 되돌아볼 수 있습니다.

The commands denote-add-links, denote-link-dired-marked-notes are suited for this task.

denote-add-links , denote-link-dired-marked-notes 명령이 이 작업에 적합합니다.

.

정규식과 일치하는 링크를 삽입합니다.

.

Dired 에 표시된 파일에서 링크를 삽입합니다.

You will create your metanote the way you use Denote ordinarily (metanotes may have the metanote keyword, among others), write an introduction or however you want to go about it, invoke the command which inserts multiple links at once (see the above-cited nodes), and continue writing.

평소 Denote 를 사용하는 방식대로 메타노트를 만들고(메타노트에는 metanote 키워드 등이 포함될 수 있습니다), 소개를 작성하거나 원하는 방식으로 작성하고, 한 번에 여러 링크를 삽입하는 명령을 호출한 다음(위에 인용된 노드 참조), 계속 작성합니다.

Metanotes can serve as entry points to groupings of individual notes. They are not the same as a filtered list of files, i.e. what you would do in Dired or the minibuffer where you narrow the list of notes to a given query. Metanotes contain the filtered list plus your thoughts about it. The act of purposefully grouping notes together and contemplating on their shared patterns is what adds value.

메타노트는 개별 노트의 그룹화 진입점 역할을 할 수 있습니다. 메타노트는 필터링된 파일 목록과는 다릅니다. 즉, Dired 나 미니버퍼에서 노트 목록을 특정 검색어로 좁히는 것과는 다릅니다. 메타노트에는 필터링된 목록과 그에 대한 회원님의 생각이 포함됩니다. 노트를 의도적으로 그룹화하고 공유 패턴에 대해 고민하는 행위가 가치를 더하는 것입니다.

Your future self will appreciate metanotes for the function they serve in encapsulating knowledge, while current you will be equipped with the knowledge derived from the deliberate self-reflection.

미래의 자아는 지식을 캡슐화하는 메타노트의 기능에 감사할 것이며, 현재의 자아는 의도적인 자기 성찰을 통해 얻은 지식으로 무장할 것입니다.

7.9. Visiting linked files via the minibuffer

7.9. 미니 버퍼를 통해 링크된 파일 방문하기

Denote has a major-mode-agnostic mechanism to collect all linked file references in the current buffer and return them as an appropriately formatted list. This list can then be used in interactive commands. The denote-find-link is such a command. It uses minibuffer completion to visit a file that is linked to from the current note. The candidates have the correct metadata, which is ideal for integration with other standards-compliant tools (). For instance, a package such as marginalia will display accurate annotations, while the embark package will be able to work its magic such as in exporting the list into a filtered Dired buffer (i.e. a familiar Dired listing with only the files of the current minibuffer session).

Denote 에는 현재 버퍼에 연결된 모든 파일 참조를 수집하여 적절한 형식의 목록으로 반환하는 메이저 모드에 구애받지 않는 메커니즘이 있습니다. 이 목록은 대화형 명령어에서 사용할 수 있습니다. denote-find-link 명령이 바로 그런 명령입니다. 이 명령은 미니버퍼 완성을 사용해 현재 노트에서 링크된 파일을 방문합니다. 후보에는 올바른 메타데이터가 있어 다른 표준 호환 도구(Extending Denote)와의 통합에 이상적입니다. 예를 들어, marginalia 같은 패키지는 정확한 주석을 표시하고, embark 패키지는 필터링된 Dired 버퍼(즉, 현재 미니버퍼 세션의 파일만 있는 익숙한 Dired 목록)로 목록을 내보내는 등의 마법을 발휘할 수 있습니다.

To visit backlinks to the current note via the minibuffer, use denote-find-backlink. This is an alternative to placing backlinks in a dedicated buffer ().

미니 버퍼를 통해 현재 노트의 백링크를 방문하려면 denote-find-backlink 을 사용하세요. 이는 전용 버퍼(백링크의 버퍼)에 백링크를 배치하는 대신 사용할 수 있습니다.

7.10. Link to a note or create it if missing

7.10. 노트에 링크하거나 누락된 경우 새로 만들기

[ Rewritten and expanded as part of 2.1.0-dev. ]

[ 2.1.0-dev 의 일부로 재작성 및 확장되었습니다.]

During a writing session, it is possible that a thought occurs which does not require immediate attention but nonetheless must be linked to from the current context. Denote can be used in this case to establish a link to an existing note or, if that is missing, to create it. The commands are denote-link-after-creating, its more flexible variant denote-link-after-creating-with-command, the denote-link-or-create, and denote-link-or-create-with-command.

글쓰기 세션 중에 즉각적인 주의가 필요하지는 않지만 현재 맥락에서 연결해야 할 생각이 떠오를 수 있습니다. 이 경우, Denote 를 사용해 기존 노트에 대한 링크를 설정하거나, 누락된 경우, 링크를 만들 수 있습니다. 명령은 denote-link-after-creating , 보다 유연한 변형인 denote-link-after-creating-with-command , denote-link-or-create , denote-link-or-create-with-command 입니다.

The command denote-link-or-create prompts for an existing file in the denote-directory in order to link to it (). At this point, the user must type in search terms that match a file name. If the input does not return any matches and the user confirms their choice to proceed (usually by typing RET twice, depending on the minibuffer settings), denote-link-or-create will call the denote command interactively to create a new note. It will then use whatever prompts denote normally has, per the user option denote-prompts (). If the title prompt is involved (the default behaviour), the denote-link-or-create sets up this prompt to have the previous input as the default title of the note to-be-created. This means that the user can type RET at the empty prompt to re-use what they typed in previously. Commands to use previous inputs from the history are also available (M-p or M-n in the minibuffer, which call previous-history-element and next-history-element by default). Accessing the history is helpful to, for example, make further edits to the available text.

denote-link-or-create 명령은 링크하기 위해 denote-directory 에 있는 기존 파일을 묻는 메시지를 표시합니다(링크 노트). 이 때 사용자는 파일 이름과 일치하는 검색어를 입력해야 합니다. 입력해도 일치하는 항목이 없고 사용자가 계속 진행을 확인하면(보통 미니버퍼 설정에 따라 RET 을 두 번 입력) denote-link-or-create 명령이 대화식으로 denote 명령을 호출해 새 노트를 만듭니다. 그런 다음 사용자 옵션 denote-prompts (표준 노트 생성)에 따라 일반적으로 denote 프롬프트가 표시되는 것을 사용합니다. 제목 프롬프트가 포함된 경우(기본 동작), denote-link-or-create 명령은 이 프롬프트가 이전 입력을 새로 만들 노트의 기본 제목으로 사용하도록 설정합니다. 즉, 사용자는 빈 프롬프트에 RET 을 입력해 이전에 입력한 내용을 다시 사용할 수 있습니다. 히스토리의 이전 입력을 사용하는 명령도 사용할 수 있습니다(미니버퍼의 M-p 또는 M-n , 기본적으로 previous-history-element 및 next-history-element 호출). 기록에 액세스하면 사용 가능한 텍스트를 추가로 편집하는 등의 작업에 유용합니다.

In the case where a file is created, the process happens in the background, meaning that the new file is not displayed. It is simply linked to from the current context.

파일이 생성되는 경우 백그라운드에서 프로세스가 진행되므로 새 파일이 표시되지 않습니다. 현재 컨텍스트에서 단순히 링크됩니다.

The denote-link-or-create-with-command is like the above, except when it is about to create the new note it first prompts for the specific file-creating command to use (). For example, the user may want to specify a signature for this new file, so they can select the denote-signature command.

denote-link-or-create-with-command URL 은 위와 비슷하지만 새 노트를 만들려고 할 때 먼저 사용할 특정 파일 생성 명령어를 묻는 메시지가 표시됩니다(진입 지점). 예를 들어, 사용자가 이 새 파일의 서명을 지정하고 싶을 경우, denote-signature 명령을 선택할 수 있습니다.

The commands denote-link-after-creating and denote-link-or-create-with-command are conceptually the same as above except they do not have the “or create” logic: they always create a new file in the backgroun (in fact, the aforementioned use those two to perform the linking, which is consistent with the composability and hackability of Denote).

denote-link-after-creating 및 denote-link-or-create-with-command 명령은 개념적으로 위와 동일하지만 "또는 생성" 로직이 없다는 점만 제외하면 항상 백그라운드에 새 파일을 생성합니다(실제로 앞서 언급한 두 명령은 이 두 가지를 사용하여 링크를 수행하므로 Denote 의 구성성 및 해킹 가능성과 일치합니다).

In all of the above, an optional prefix argument (C-u by default) creates a link that consists of just the identifier. This has the same meaning as in the regular denote-link command.

위의 모든 경우에서 선택적 접두사 인수(기본값은 C-u )는 식별자만으로 구성된 링크를 생성합니다. 이는 일반 denote-link 명령과 동일한 의미를 갖습니다.

Denote provides similar functionality for opening an existing note or creating a new one ().

Denote 는 기존 노트를 열거나 새 노트를 만들 때 유사한 기능을 제공합니다(기존 노트 열기 또는 누락된 경우 만들기).

7.11. Miscellaneous information about links

7.11. 링크에 대한 기타 정보

For convenience, the denote-link command has an alias called denote-insert-link. The denote-backlinks can also be used as denote-show-backlinks-buffer. While denote-add-links is aliased denote-link-insert-links-matching-regexp. The purpose of these aliases is to offer alternative, more descriptive names of select commands.

편의를 위해 denote-link 명령에는 denote-insert-link 이라는 별칭이 있습니다. denote-backlinks 는 denote-show-backlinks-buffer 로도 사용할 수 있습니다. denote-add-links 의 별칭은 denote-link-insert-links-matching-regexp 입니다. 이러한 별칭의 목적은 선택 명령에 대해 보다 설명적인 대체 이름을 제공하기 위한 것입니다.

8. Choose which commands to prompt for

프롬프트할 명령을 선택합니다.

[ Part of 2.1.0-dev. ]

[ 2.1.0 개발 중 일부 ]입니다.

The user option denote-commands-for-new-notes specifies a list of commands that are available at the denote-command-prompt. This prompt is used by Denote commands that ask the user how to create a new note, as described elsewhere in this manual:

사용자 옵션 denote-commands-for-new-notes 은 denote-command-prompt 에서 사용할 수 있는 명령 목록을 지정합니다. 이 프롬프트는 이 매뉴얼의 다른 곳에서 설명한 대로 사용자에게 새 노트를 만드는 방법을 묻는 Denote 명령에 사용됩니다:

• [[#h:ad91ca39-cf10-4e16-b224-fdf78f093883][Open an existing note or create it if missing

  기존 노트를 열거나 누락된 경우 새로 만들기]]

• [[#h:b6056e6b-93df-4e6b-a778-eebd105bac46][Link to a note or create it if missing

  노트에 링크하거나 누락된 경우 새로 만들기]]

The default value includes all the basic file-creating commands (). Users may customise this value if (i) they only want to see fewer options and/or (ii) wish to include their own custom command in the list ().

기본값에는 모든 기본 파일 생성 명령어가 포함됩니다(입력 지점). 사용자는 (i) 더 적은 수의 옵션만 표시하고 싶거나 (ii) 목록에 자신만의 사용자 지정 명령을 포함하려는 경우 이 값을 사용자 지정할 수 있습니다('나만의 편리한 명령어 작성').

9. Fontification in Dired

Dired 의 글꼴화

One of the upsides of Denote's file-naming scheme is the predictable pattern it establishes, which appears as a near-tabular presentation in a listing of notes (i.e. in Dired). The denote-dired-mode can help enhance this impression, by fontifying the components of the file name to make the date (identifier) and keywords stand out.

Denote 의 파일 명명 체계의 장점 중 하나는 노트 목록(예: Dired)에서 표에 가까운 형태로 나타나는 예측 가능한 패턴을 설정할 수 있다는 점입니다. denote-dired-mode 파일 이름의 구성 요소를 글꼴화해 날짜(식별자)와 키워드를 돋보이게 함으로써 이러한 인상을 개선하는 데 도움이 될 수 있습니다.

There are two ways to set the mode. Either use it for all directories, which probably is not needed:

모드를 설정하는 방법은 두 가지가 있습니다. 모든 디렉터리에 사용하거나 필요하지 않을 수도 있습니다:

(add-hook 'dired-mode-hook #'denote-dired-mode)

Or configure the user option denote-dired-directories and then set up the function denote-dired-mode-in-directories:

또는 사용자 옵션 denote-dired-directories 을 구성한 다음 함수 denote-dired-mode-in-directories 를 설정합니다:

;; We use different ways to specify a path for demo purposes.
(setq denote-dired-directories
      (list denote-directory
            (thread-last denote-directory (expand-file-name "attachments"))
            (expand-file-name "~/Documents/vlog")))
 
(add-hook 'dired-mode-hook #'denote-dired-mode-in-directories)

The faces we define for this purpose are:

이를 위해 정의한 얼굴은 다음과 같습니다:

• denote-faces-date
• denote-faces-delimiter
• denote-faces-extension
• denote-faces-keywords
• denote-faces-subdirectory
• denote-faces-time
• denote-faces-title

For the time being, the diredfl package is not compatible with this facility.

당분간 diredfl 패키지는 이 기능과 호환되지 않습니다.

The denote-dired-mode does not only fontify note files that were created by Denote: it covers every file name that follows our naming conventions (). This is particularly useful for scenaria where, say, one wants to organise their collection of PDFs and multimedia in a systematic way (and, perhaps, use them as attachments for the notes Denote produces if you are writing Org notes and are using its standand attachments' facility).

denote-dired-mode 는 Denote 에서 만든 노트 파일의 폰트화뿐만 아니라, 저희의 명명 규칙(파일 명명 체계)을 따르는 모든 파일 이름을 포함합니다. 이 기능은 예를 들어, PDF 와 멀티미디어 컬렉션을 체계적으로 정리하고 싶을 때 특히 유용합니다(조직 노트를 작성하고 스탠드와 첨부파일 기능을 사용하는 경우, Denote 가 생성한 노트의 첨부파일로 사용할 수도 있습니다).

10. Automatically rename Denote buffers

버퍼 표시 이름 자동 변경

[ Refactored and expanded as part of 2.1.0-dev. ]

[ 2.1.0-dev 의 일부로 리팩터링 및 확장되었습니다.]

The minor mode denote-rename-buffer-mode provides the means to automatically rename the buffer of a Denote file upon visiting the file. This applies both to existing Denote files as well as new ones (). Enable the mode thus:

부 모드 denote-rename-buffer-mode 는 파일 방문 시 Denote 파일의 버퍼 이름을 자동으로 변경하는 수단을 제공합니다. 이는 기존 Denote 파일은 물론 새 파일(진입 지점)에도 적용됩니다. 이 모드를 활성화하려면 다음과 같이 하세요:

(denote-rename-buffer-mode 1)

Buffers are named by applying the function specified in the user option denote-rename-buffer-function. The default function is denote-rename-buffer: it renames the buffer based on the template set in the user option denote-rename-buffer-format. By default, the formatting template targets only the TITLE component of the file name (). Other fields are explained elsewhere in this manual ().

버퍼의 이름은 사용자 옵션 denote-rename-buffer-function 에 지정된 함수를 적용하여 지정합니다. 기본 함수는 denote-rename-buffer 이며, 사용자 옵션 denote-rename-buffer-format 에 설정된 템플릿에 따라 버퍼의 이름을 바꿉니다. 기본적으로 서식 지정 템플릿은 파일 이름의 TITLE 구성 요소(파일 이름 지정 체계)만 대상으로 합니다. 다른 필드는 이 설명서의 다른 곳에 설명되어 있습니다(버퍼 이름 바꾸기 형식).

Note that renaming a buffer is not the same as renaming a file (). The former is just for convenience inside of Emacs. Whereas the latter is for writing changes to disk, making them available to all programs.

버퍼의 이름을 바꾸는 것은 파일 이름을 바꾸는 것(파일 이름 바꾸기)과는 다릅니다. 전자는 Emacs 내부의 편의를 위한 것입니다. 반면 후자는 디스크에 변경 내용을 기록하여 모든 프로그램에서 사용할 수 있도록 하기 위한 것입니다.

10.1. The denote-rename-buffer-format10.1. 10.1. denote-rename-buffer-format

[ Part of 2.1.0-dev. ]

[ 2.1.0 개발 중 일부 ]입니다.

The user option denote-rename-buffer-format controls how the function denote-rename-buffer chooses the name of the buffer-to-be-renamed.

사용자 옵션 denote-rename-buffer-format 은 denote-rename-buffer 함수가 이름을 바꿀 버퍼의 이름을 선택하는 방법을 제어합니다.

The value of this user option is a string. The following specifiers are placeholders for Denote file name components ():

이 사용자 옵션의 값은 문자열입니다. 다음 지정자는 파일 이름 구성 요소 표시( 파일 이름 지정 체계)의 자리 표시자입니다:

• The %t is the Denote TITLE of the file.

  %t 은 파일의 TITLE 을 나타냅니다.

• The %i is the Denote IDENTIFIER of the file.

  %i 은 파일의 IDENTIFIER 을 나타냅니다.

• The %d is the same as %i (DATE mnemonic).

  %d 는 %i ( DATE 니모닉)과 동일합니다.

• The %s is the Denote SIGNATURE of the file.

  %s 은 파일의 SIGNATURE 을 나타냅니다.

• The %k is the Denote KEYWORDS of the file.

  %k 은 파일의 KEYWORDS 을 나타냅니다.

• The %% is a literal percent sign.

  %% 은 문자 그대로 퍼센트 기호입니다.

In addition, the following flags are available for each of the specifiers:

또한 각 지정자에 대해 다음과 같은 플래그를 사용할 수 있습니다:

0 : Pad to the width, if given, with zeros instead of spaces.

지정된 경우 공백 대신 0 을 사용하여 너비를 입력합니다.

- : Pad to the width, if given, on the right instead of the left.

너비가 지정된 경우 왼쪽이 아닌 오른쪽으로 패드합니다.

< : Truncate to the width and precision, if given, on the left.

지정된 경우 왼쪽에서 너비와 정밀도로 잘라냅니다.

> : Truncate to the width and precision, if given, on the right.

지정된 경우 오른쪽에서 너비와 정밀도로 잘라냅니다.

^ : Convert to upper case.

대문자로 변환합니다.

_ : Convert to lower case.

소문자로 변환합니다.

When combined all together, the above are written thus:

위의 내용을 모두 합치면 다음과 같이 작성됩니다:

%<flags><width><precision>SPECIFIER-CHARACTER

Any other string it taken as-is. Users may want, for example, to include some text that makes Denote buffers stand out, such as a [D] prefix. Examples:

그 외의 문자열은 그대로 사용합니다. 예를 들어, 사용자는 [D] 접두사와 같이 버퍼 표시를 돋보이게 하는 일부 텍스트를 포함할 수 있습니다. 예시:

;; Use the title (default)
(setq denote-rename-buffer-format "%t")
 
;; Use the title and keywords with some emoji in between
(setq denote-rename-buffer-format "%t 🤨 %k")
 
;; Use the title with a literal "[D]" before it
(setq denote-rename-buffer-format "[D] %t")

Users who need yet more flexibility are best served by writing their own function and assigning it to the denote-rename-buffer-function.

더 많은 유연성이 필요한 사용자는 자신만의 함수를 작성하여 denote-rename-buffer-function 에 할당하는 것이 가장 좋습니다.

11. Use Org dynamic blocks

1. 조직 동적 블록 사용

Denote can optionally integrate with Org mode's “dynamic blocks” facility. Start by loading the relevant library:

선택적으로 조직 모드의 "동적 블록" 기능과 통합할 수 있습니다. 관련 라이브러리를 로드하는 것으로 시작하세요:

(require 'denote-org-dblock)

A dynamic block gets its contents by evaluating a given function, depending on the type of block. The type of block and its parameters are stated in the opening #+BEGIN line of the block. Typing C-c C-c with point on that line runs the function, with the given arguments, and populates the block's contents accordingly.

동적 블록은 블록 유형에 따라 주어진 함수를 평가하여 콘텐츠를 가져옵니다. 블록 유형과 해당 매개변수는 블록의 시작 부분 #+BEGIN 줄에 명시되어 있습니다. 해당 줄에 점과 함께 C-c C-c 을 입력하면 주어진 인수를 사용하여 함수가 실행되고 그에 따라 블록의 콘텐츠가 채워집니다.

Denote leverages Org dynamic blocks to streamline the inclusion of (i) links to notes whose name matches a given search query (like denote-add-links) and (ii) backlinks to the current note (similar to denote-find-backlink).

Denote 는 조직 동적 블록을 활용해 (i) 이름이 특정 검색어와 일치하는 노트 링크(예: denote-add-links )와 (ii) 현재 노트에 대한 백링크(예: denote-find-backlink )의 포함을 간소화할 수 있습니다.

These two types of blocks are named denote-links and denote-backlinks respectively. The latter does not accept any parameters, while the former does, which we explain below by also demonstrating how dynamic blocks are written.

이 두 가지 유형의 블록의 이름은 각각 denote-links 및 denote-backlinks 입니다. 후자는 매개변수를 허용하지 않는 반면 전자는 허용하며, 아래에서 동적 블록이 작성되는 방법을 설명합니다.

A dynamic block looks like this:

동적 블록은 다음과 같습니다:

#+BEGIN: denote-links :regexp "_journal"
 
#+END:

Here we have the denote-links type, with the :regexp parameter. The value of the :regexp parameter is the same as that of the command denote-add-links (). It can only use the notation of the rx macro, as explained in the Emacs Lisp Reference Manual (evaluate: (info "(elisp) Rx Notation")). The linked entry provides practical examples of patterns that make good use of Denote's file-naming scheme ().

여기에는 :regexp 매개 변수가 있는 denote-links 유형이 있습니다. :regexp 매개 변수의 값은 denote-add-links ( 정규식과 일치하는 링크 삽입) 명령의 값과 동일합니다. 이 명령은 Emacs Lisp 참조 설명서(평가: (info "(elisp) Rx Notation") )에 설명된 대로 rx 매크로의 표기법만 사용할 수 있습니다. 링크된 항목은 Denote 의 파일 이름 지정 체계( 파일 이름 지정 체계)를 잘 활용하는 패턴의 실제 예제를 제공합니다.

In this example, we instruct Org to produce a list of all notes that include the journal keyword in their file name (keywords in file names are prefixed with the underscore). So the following:

이 예에서는 파일 이름에 journal 키워드가 포함된 모든 노트의 목록을 만들도록 Org 에 지시합니다(파일 이름의 키워드는 밑줄이 앞에 붙습니다). 그래서 다음과 같습니다:

#+BEGIN: denote-links :regexp "_journal"
 
#+END:

Becomes something like this once we type C-c C-c with point on the #+BEGIN line (Org makes the links look prettier by default):

#+BEGIN 줄에 점을 찍고 C-c C-c 를 입력하면 다음과 같이 됩니다(조직은 기본적으로 링크를 더 예쁘게 보이게 합니다):

#+BEGIN: denote-links :regexp "_journal"
- [[denote:20220616T182958][Feeling butterflies in your stomach]]
- [[denote:20220818T221036][Between friend and stranger]]
#+END:

The dynamic block takes care to keep the list in order and to add any missing links when the block is evaluated anew.

동적 블록은 목록을 순서대로 유지하고 블록이 새로 평가될 때 누락된 링크를 추가하도록 관리합니다.

Depending on one's workflow, the dynamic block can be instructed to list only those links which are missing from the current buffer (similar to denote-add-missing-links). Adding the :missing-only parameter with a non-nil value achieves this effect. The #+BEGIN line looks like this:

워크플로에 따라 동적 블록에 현재 버퍼에서 누락된 링크만 나열하도록 지시할 수 있습니다( denote-add-missing-links )와 유사). nil 값이 아닌 :missing-only 매개변수를 추가하면 이 효과를 얻을 수 있습니다. #+BEGIN 줄은 다음과 같습니다:

#+BEGIN: denote-links :regexp "_journal" :missing-only t

To reverse the order links appear in, add :reverse t to the #+BEGIN line.

주문 링크가 표시되는 순서를 바꾸려면 #+BEGIN 줄에 :reverse t 을 추가합니다.

The denote-links block can also accept a :block-name parameter with a string value that names the block. Once the dynamic block is evaluated, a #+NAME is prepended to the block's contents. This can be referenced in other source blocks to parse the named block's contents as input of another process. The details are beyond the scope of Denote.

denote-links 블록은 블록의 이름을 지정하는 문자열 값과 함께 :block-name 매개 변수를 사용할 수도 있습니다. 동적 블록이 평가되면 블록의 콘텐츠에 #+NAME 가 추가됩니다. 이를 다른 소스 블록에서 참조하여 명명된 블록의 콘텐츠를 다른 프로세스의 입력으로 파싱할 수 있습니다. 자세한 내용은 Denote 의 범위를 벗어납니다.

As for the denote-backlinks dynamic block type, it simply produces a list of notes that link to the current file. It accepts no parameters and looks like this:

denote-backlinks 동적 블록 유형은 단순히 현재 파일로 연결되는 노트 목록을 생성합니다. 매개변수를 허용하지 않으며 다음과 같이 보입니다:

#+BEGIN: denote-backlinks
 
#+END:

The Org manual describes the technicalities of Dynamic Blocks. Evaluate:

조직 매뉴얼에서는 동적 블록의 기술에 대해 설명합니다. 평가:

(info "(org) Dynamic Blocks")

Dynamic blocks are particularly useful for metanote entries that reflect on the status of earlier notes ().

동적 블록은 이전 노트의 상태를 반영하는 메타노트 항목에 특히 유용합니다('메타노트 작성').

12. Minibuffer histories

Denote has a dedicated minibuffer history for each one of its prompts. This practically means that using M-p (previous-history-element) and M-n (next-history-element) will only cycle through the relevant record of inputs, such as your latest titles in the TITLE prompt, and keywords in the KEYWORDS prompt.

Denote 에는 각 프롬프트에 대한 전용 미니버퍼 기록이 있습니다. 즉, M-p ( previous-history-element ) 및 M-n ( next-history-element )을 사용하면 TITLE 프롬프트의 최신 제목, KEYWORDS 프롬프트의 키워드 등 관련 입력 기록만 순환합니다.

The built-in savehist library saves minibuffer histories. Sample configuration:

내장된 savehist 라이브러리는 미니버퍼 기록을 저장합니다. 샘플 구성:

(require 'savehist)
(setq savehist-file (locate-user-emacs-file "savehist"))
(setq history-length 500)
(setq history-delete-duplicates t)
(setq savehist-save-minibuffer-history t)
(add-hook 'after-init-hook #'savehist-mode)

13. Extending Denote

Denote 는 앞서 언급한 파일 명명 체계에 따라 노트를 만들고 노트 사이를 연결하는 좁은 범위의 도구입니다. 다른 일반적인 작업의 경우, 사용자는 표준 Emacs 기능이나 전문화된 타사 패키지를 사용하는 것이 좋습니다. 이 섹션에서 자세한 내용을 다룹니다.

Denote is a tool with a narrow scope: create notes and link between them, based on the aforementioned file-naming scheme. For other common operations the user is advised to rely on standard Emacs facilities or specialised third-party packages. This section covers the details.

13.1. Keep a journal or diary

일기 쓰기

[ 2.1.0-dev 의 일부로 재작성되었으며, 이제 사용자가 Denote 설정의 일부로 로드할 수 있는 denote-journal-extras.el 파일이 옵션으로 포함되어 있습니다. ]

Denote 는 광범위하게 "노트"(항목의 포인트)로 간주되는 새 파일을 만들 수 있는 범용 메커니즘을 제공합니다. 이러한 파일은 저널의 일일 항목이 될 수 있습니다. 일반적인 denote 명령을 사용해 저널을 관리할 수도 있지만, 저희는 denote-journal-extras.el 의 일부로 편의 옵션과 명령어 세트를 옵션으로 제공합니다. 이를 사용하려면 다음 Denote 구성을 추가하세요:

(require 'denote-journal-extras.el)

denote-journal-extras-new-entry 명령은 저널에 새 항목을 만듭니다. 이러한 파일의 파일명은 denote-journal-extras-keyword 이며, 기본값은 journal 입니다 (The file-naming scheme). 사용자는 이 키워드를 임의의 문자열로 설정할 수 있습니다(단일 단어가 선호됨). 새 저널 항목은 denote-directory 또는 그 하위 디렉터리에 저장할 수 있습니다. 사용자의 편의를 위해 새 저널 항목은 denote-journal-extras-directory 에 배치되며, 기본적으로 denote-directory 의 하위 디렉터리인 journal 에 저장됩니다.

denote-journal-extras-directory 가 0 이면 denote-directory 가 사용됩니다. 따라서 저널 항목은 다른 모든 노트와 함께 목록에 표시됩니다. denote-journal-extras-keyword (검색 또는 필터링을 위한 파일 명명 체계의 특징)를 검색해 쉽게 검색할 수 있습니다.

또한 denote-journal-extras-new-entry 명령은 현재 날짜를 새 항목의 제목으로 사용합니다. 정확한 형식은 사용자 옵션 denote-journal-extras-title-format 으로 제어됩니다. denote-journal-extras-title-format 및 해당 스타일에 허용되는 값은 다음과 같습니다:

| Symbol | Style | |-------------------------|-----------------------------------| | day | Monday | | day-date-month-year | Monday 19 September 2023 | | day-date-month-year-24h | Monday 19 September 2023 20:49 | | day-date-month-year-12h | Monday 19 September 2023 08:49 PM |

For example:

(setq denote-journal-extras-title-format 'day-date-month-year)

이 사용자 옵션의 값이 nil 인 경우 denote-journal-extras-new-entry 에 제목을 입력하라는 메시지가 표시됩니다.

denote-journal-extras-new-entry 명령은 선택적으로 DATE 인수를 사용할 수도 있습니다. 대화식으로 호출될 때 이 인수는 범용 접두사입니다(예: 기본 키 바인딩이 있는 C-u ). DATE 를 사용하면 새 저널 항목을 만들 날짜를 묻는 메시지가 표시됩니다. 날짜 프롬프트는 선택적으로 조직 날짜+달력 선택 인터페이스( denote-date-prompt-use-org-read-date 옵션)를 사용할 수 있습니다.

워크플로우 측면에서는 현재 날짜를 제목으로 사용하는 것이 일일 일기를 작성하는 데 더 좋습니다. 임의의 제목을 입력하라는 메시지는 생각이나 사건 같은 것을 기록하려는 사람들에게 더 적합합니다(일반 denote 명령이나 denote-subdirectory 명령으로도 가능하지만).

denote-journal-extras-new-entry 명령은 완료된 후 일반 훅 denote-journal-extras-hook 을 호출합니다. 사용자는 이를 활용하여 GNU ELPA 의 tmr 패키지로 타이머를 설정하는 등의 결과를 생성할 수 있습니다(타이머를 사용한 저널링).

denote-journal-extras-new-or-existing-entry 명령은 기존 저널 항목을 찾거나 새 저널 항목을 만듭니다. 저널 항목은 파일 이름에 denote-journal-extras-keyword 가 포함된 항목입니다. 현재 날짜에 대한 저널 항목이 여러 개 있는 경우, 미니버퍼 완성을 사용하여 그 중 하나를 선택하라는 메시지를 표시합니다. 항목이 하나만 있으면 바로 해당 항목을 방문합니다. 저널 항목이 없는 경우 위에 설명된 대로 denote-journal-extra-new-entry 을 호출하여 저널 항목을 만듭니다.

---

[ Rewritten as part of 2.1.0-dev, which now includes the optional denote-journal-extras.el file that the user can load as part of their Denote setup. ]

Denote provides a general-purpose mechanism to create new files that broadly count as “notes” (). Such files can be daily entries in a journal. While it is possible to use the generic denote command to maintain a journal, we provide an optional set of convenience options and commands as part of denote-journal-extras.el. To use those, add the following the Denote configuration:

The command denote-journal-extras-new-entry creates a new entry in the journal. Such a file has the denote-journal-extras-keyword, which is journal by default (). The user can set this keyword to an arbitrary string (single word is preferred). New journal entries can be stored in the denote-directory or subdirectory thereof. To make it easier for the user, the new journal entry will be placed in denote-journal-extras-directory, which defaults to a subdirectory of denote-directory called journal.

If denote-journal-extras-directory is nil, the denote-directory is used. Journal entries will thus be in a flat listing together with all other notes. They can still be retrieved easily by searching for the denote-journal-extras-keyword ().

Furthermore, the command denote-journal-extras-new-entry will use the current date as the title of the new entry. The exact format is controlled by the user option denote-journal-extras-title-format. Acceptable values for denote-journal-extras-title-format and their corresponding styles are:

If the value of this user option is nil, then denote-journal-extras-new-entry will prompt for a title.

The denote-journal-extras-new-entry command also accepts an optional DATE argument. When called internactively, this is a universal prefix (e.g. C-u with the default key bindings). With DATE, it prompts for a date to create a new journal entry for. The date prompt can optionally use the Org date+calendar selection interface ().

In terms of workflow, using the current date as the title is better for maintaining a daily journal. A prompt for an arbitrary title is more suitable for those who like to keep a record of something like a thought or event (though this can also be achieved by the regular denote command or maybe denote-subdirectory).

The denote-journal-extras-new-entry command calls the normal hook denote-journal-extras-hook after it is done. The user can leverage this to produce consequences therefrom, such as to set a timer with the tmr package from GNU ELPA ().

The command denote-journal-extras-new-or-existing-entry locates an existing journal entry or creates a new one. A journal entry is one that has denote-journal-extras-keyword as part of its file name. If there are multiple journal entries for the current date, it prompts for one among them using minibuffer completion. If there is only one, it visits it outright. If there is no journal entry, it creates one by calling denote-journal-extra-new-entry (as described above).

13.1.1. Journaling with a timer

tmr 을 사용하는 타이머 기능 신박하다.

타이머를 사용한 저널링

[ Revised as part of 2.1.0-dev to conform with how we now tend to the needs of users who use Denote for journaling purposes (). ]

[ 2.1.0 개발 버전에서 저널링 목적(일기 또는 일기 쓰기)으로 Denote 를 사용하는 사용자들의 니즈에 부합하도록 수정되었습니다. ]

Sometimes journaling is done with the intent to hone one's writing skills. Perhaps you are learning a new language or wish to communicate your ideas with greater clarity and precision. As with everything that requires a degree of sophistication, you have to work for it---write, write, write!

때로는 글쓰기 실력을 연마하기 위해 일기를 쓰기도 합니다. 새로운 언어를 배우고 있거나 자신의 생각을 더 명확하고 정확하게 전달하고 싶을 수도 있습니다. 어느 정도의 정교함이 필요한 모든 일과 마찬가지로, 글쓰기를 위해서는 쓰고, 쓰고, 또 써야 합니다!

One way to test your progress is to set a timer. It helps you gauge your output and its quality. To use a timer with Emacs, consider the tmr package. A new timer can be set with something like this:

진행 상황을 테스트하는 한 가지 방법은 타이머를 설정하는 것입니다. 타이머를 설정하면 결과물과 품질을 측정하는 데 도움이 됩니다. Emacs 에서 타이머를 사용하려면 tmr 패키지를 고려하세요. 다음과 같이 새 타이머를 설정할 수 있습니다:

;; Set 10 minute timer with the given description
(tmr "10" "Practice writing in my journal")

To make this timer start as soon as a new journal entry is created with the command denote-journal-extras-new-entry, add a function to the denote-journal-extras-hook. For example:

denote-journal-extras-new-entry 명령으로 새 저널 항목을 만드는 즉시 이 타이머가 시작되도록 하려면 denote-journal-extras-hook 에 함수를 추가하세요. 예를 들어

;; Add an anonymous function, which is more difficult to modify after
;; the fact:
(add-hook 'denote-journal-extras-hook (lambda ()
                                        (tmr "10" "Practice writing in my journal")))
 
;; Or write a small function that you can then modify without
;; revaluating the hook:
(defun my-denote-tmr ()
  (tmr "10" "Practice writing in my journal"))
 
(add-hook 'denote-journal-extras-hook 'my-denote-tmr)
 
;; Or to make it fully featured, define variables for the duration and
;; the description and set it up so that you only need to modify
;; those:
(defvar my-denote-tmr-duration "10")
 
(defvar my-denote-tmr-description "Practice writing in my journal")
 
(defun my-denote-tmr ()
  (tmr my-denote-tmr-duration my-denote-tmr-description))
 
(add-hook 'denote-journal-extras-hook 'my-denote-tmr)

Once the timer elapses, stop writing and review your performance. Practice makes perfect!

타이머가 경과하면 글쓰기를 중단하고 자신의 성과를 검토하세요. 연습이 완벽을 만듭니다!

Sources for tmr:

• Package name (GNU ELPA): tmr
• Official manual: https://protesilaos.com/emacs/tmr
• Change log: https://protesilaos.com/emacs/denote-changelog
• Git repo on SourceHut: https://git.sr.ht/~protesilaos/tmr
  • Mirrors:
    • GitHub: https://github.com/protesilaos/tmr
    • GitLab: https://gitlab.com/protesilaos/tmr
• Mailing list: https://lists.sr.ht/~protesilaos/tmr

13.2. Create a note with the region's contents

영역(Region)의 콘텐츠로 노트 만들기

[2.1.0-dev 의 일부로 재작성되어 여기에 문서화되어 있던 사용자 정의 함수를 대체하는 denote-region 명령이 포함되었습니다. ]

denote-region 명령은 활성 영역의 콘텐츠를 가져온 다음 제목과 키워드를 입력하라는 메시지를 표시합니다. 새 노트가 만들어지면 그 안에 해당 영역의 콘텐츠가 삽입됩니다. 이 기능은 텍스트 일부를 빠르게 자세히 설명하거나 나중에 참조할 수 있도록 캡처할 때 유용합니다.

활성 영역이 없는 경우 denote-region 는 denote 명령을 호출하기만 하면 평소와 같은 방식으로 작동합니다.

When the denote-region command is called with an active region, it finalises its work by calling denote-region-after-new-note-functions. This is an abnormal hook, meaning that the functions added to it are called with arguments. The arguments are two, representing the beginning and end positions of the newly inserted text.

denote-region 명령이 활성 영역과 함께 호출되면 denote-region-after-new-note-functions 을 호출하여 작업을 완료합니다. 이것은 비정상적인 훅으로, 인수를 사용하여 추가된 함수가 호출된다는 의미입니다. 인수는 새로 삽입된 텍스트의 시작 및 끝 위치를 나타내는 두 개입니다.

A common use-case for Org mode users is to call the command org-insert-structure-template after a region is inserted. Emacs will thus prompt for a structure template, such as the one corresponding to a source block. In this case the function added to denote-region-after-new-note-functions does not actually need aforementioned arguments: it can simply declare those as ignored by prefixing the argument names with an underscore (an underscore is enough, but it is better to include a name for clarity). For example, the following will prompt for a structure template as soon as denote-region is done:

조직 모드 사용자의 일반적인 사용 사례는 영역이 삽입된 후 org-insert-structure-template 명령을 호출하는 것입니다. 그러면 Emac 은 소스 블록에 해당하는 것과 같은 구조 템플릿을 묻는 메시지를 표시합니다. 이 경우 denote-region-after-new-note-functions 에 추가된 함수는 실제로 앞서 언급한 인수가 필요하지 않으며, 인수 이름 앞에 밑줄을 붙여 무시됨으로 선언할 수 있습니다(밑줄로 충분하지만 명확성을 위해 이름을 포함하는 것이 좋습니다). 예를 들어 다음은 denote-region 가 완료되는 즉시 구조 템플릿을 요청하는 메시지입니다:

(defun my-denote-region-org-structure-template (_beg _end)
  (when (derived-mode-p 'org-mode)
    (activate-mark)
    (call-interactively 'org-insert-structure-template)))
 
(add-hook 'denote-region-after-new-note-functions #'my-denote-region-org-structure-template)

Remember that denote-region-after-new-note-functions are not called if denote-region is used without an active region.

활성 지역 없이 denote-region 을 사용하는 경우 denote-region-after-new-note-functions 은 호출되지 않습니다.

---

[ Rewritten as part of 2.1.0-dev to include the denote-region command which supersedes a custom function that was once documented herein. ]

The command denote-region takes the contents of the active region and then prompts for a title and keywords. Once a new note is created, it inserts the contents of the region therein. This is useful to quickly elaborate on some snippet of text or capture it for future reference.

13.3. Split an Org subtree into its own note

조직 하위 트리를 자체 노트로 분할하기

With Org files in particular, it is common to have nested headings which could be split off into their own standalone notes. In Org parlance, an entry with all its subheadings is a “subtree”. With the following code, the user places the point inside the heading they want to split off and invokes the command my-denote-org-extract-subtree. It will create a note using the heading's text and tags for the new file. The contents of the subtree become the contents of the new note and are removed from the old one.

특히 조직 파일의 경우, 중첩된 제목을 독립된 노트로 분리할 수 있는 중첩 제목이 있는 경우가 많습니다. Org 용어로, 모든 하위 제목이 있는 항목을 "하위 트리"라고 합니다. 다음 코드를 사용해 사용자는 분할하고 싶은 제목 안에 포인트를 배치하고 my-denote-org-extract-subtree 명령을 호출합니다. 그러면 제목의 텍스트와 새 파일의 태그를 사용해 노트가 만들어집니다. 하위 트리의 콘텐츠가 새 노트의 콘텐츠가 되고 기존 노트에서 제거됩니다.

(defun my-denote-org-extract-subtree (&optional silo)
  "Create new Denote note using current Org subtree.
Make the new note use the Org file type, regardless of the value
of `denote-file-type'.
 
With an optional SILO argument as a prefix (\\[universal-argument]),
ask user to select a SILO from `my-denote-silo-directories'.
 
Use the subtree title as the note's title.  If available, use the
tags of the heading are used as note keywords.
 
Delete the original subtree."
  (interactive
   (list (when current-prefix-arg
           (completing-read "Select a silo: " my-denote-silo-directories nil t))))
  (if-let ((text (org-get-entry))
           (heading (org-get-heading :no-tags :no-todo :no-priority :no-comment)))
      (let ((element (org-element-at-point))
            (tags (org-get-tags))
            (denote-user-enforced-denote-directory silo))
        (delete-region (org-entry-beginning-position)
                       (save-excursion (org-end-of-subtree t) (point)))
        (denote heading
                tags
                'org
                nil
                (or
                 ;; Check PROPERTIES drawer for :created: or :date:
                 (org-element-property :CREATED element)
                 (org-element-property :DATE element)
                 ;; Check the subtree for CLOSED
                 (org-element-property :raw-value
                                       (org-element-property :closed element))))
        (insert text))
    (user-error "No subtree to extract; aborting")))

다른 워크플로우가 있으신가요? 공식 채널(기여하기)에서 언제든지 논의해 주세요.

13.4. Narrow the list of files in Dired

Dired 에서 파일 목록 좁히기

Emacs 의 표준 파일 관리자(또는 디렉토리 편집기)는 정규식을 읽어 일치하는 파일을 표시할 수 있습니다. 이 명령은 dired-mark-files-regexp 이며, 기본적으로 % m 에 바인딩됩니다. 예를 들어 % m _denote 은 denote 키워드가 있는 모든 파일과 일치합니다(검색 또는 필터링을 위한 파일 이름 지정 체계의 특징).

파일이 일치하면 사용자는 (i) narrow the list to the maching items (일치하는 항목으로 목록의 범위를 좁히거나) (ii) exclude the maching items from the list (일치하는 항목을 목록에서 제외하는 두 가지 옵션을 선택할 수 있습니다.)

전자의 경우 t (기본적으로 dired-toggle-marks 명령 호출)를 입력한 다음 k ( dired-do-kill-lines )을 눌러 마크를 전환합니다. 나머지 파일은 앞서 제공한 정규식과 일치하는 파일입니다.

일치하는 항목을 필터링하는 후자의 경우 k 명령( dired-do-kill-lines )을 사용하여 목록에서 표시된 파일을 생략하기만 하면 됩니다.

이러한 시퀀스를 결합하여 목록의 범위를 점차 좁힐 수 있습니다. dired-do-kill-lines 은 파일을 삭제하는 것이 아니라 현재 보기에서 파일을 숨길 뿐이라는 점에 유의하세요.

g ( revert-buffer )를 사용하여 원래 목록으로 되돌립니다.

For a convenient wrapper, consider this example:

(defvar prot-dired--limit-hist '()
  "Minibuffer history for `prot-dired-limit-regexp'.")
 
;;;###autoload
(defun prot-dired-limit-regexp (regexp omit)
  "Limit Dired to keep files matching REGEXP.
 
With optional OMIT argument as a prefix (\\[universal-argument]),
exclude files matching REGEXP.
 
Restore the buffer with \\<dired-mode-map>`\\[revert-buffer]'."
  (interactive
   (list
    (read-regexp
     (concat "Files "
             (when current-prefix-arg
               (propertize "NOT " 'face 'warning))
             "matching PATTERN: ")
     nil 'prot-dired--limit-hist)
    current-prefix-arg))
  (dired-mark-files-regexp regexp)
  (unless omit (dired-toggle-marks))
  (dired-do-kill-lines))

13.5. Use dired-virtual-mode for arbitrary file listings

임의의 파일 목록에 대한 dired-virtual-mode 사용

Emacs 의 Dired 는 유닉스 ls 명령을 기반으로 기능을 구축한 강력한 파일 관리자입니다. 이 설명서의 다른 곳에서 언급했듯이, 사용자는 Dired 가 내용을 표시하는 데 사용하는 ls 플래그를 업데이트할 수 있습니다(마지막으로 수정한 날짜별로 정렬하고 싶은데 왜 Denote 가 허용하지 않나요?).

(I want to sort by last modified, why won't Denote let me?) 참고

~Dired 가 할 수 없는 작업~은 ls -l | sort -t _ -k2 와 같이 파이프된 명령으로 생성된 결과의 출력을 파싱하는 것입니다. 이 특정 예제는 규칙(파일 이름 지정 체계)에 따라 파일 이름의 밑줄로 구분된 두 번째 필드를 대상으로 합니다. 즉, 다음과 같은 경우 정렬 키로 "알파"와 일치합니다:

20220929T200432--testing-file-one__alpha.txt

그런 다음 Dired 가 식별자별로 파일을 정렬하는 방법을 고려해 보세요:

20220929T200432--testing-file-one__alpha.txt
20220929T200532--testing-file-two__beta.txt
20220929T200632--testing-file-three__alpha.txt
20220929T200732--testing-file-four__beta.txt

반면에 명령줄에서는 다음과 같은 결과를 얻을 수 있습니다:

$ ls | sort -t _ -k 2
20220929T200432--testing-file-one__alpha.txt
20220929T200632--testing-file-three__alpha.txt
20220929T200532--testing-file-two__beta.txt
20220929T200732--testing-file-four__beta.txt

dired-virtual-mode 에서 그 유용성을 확인할 수 있습니다. ls -l 를 포함하도록 명령줄 호출을 조정하면 이 모드는 나열된 파일에서 Dired 처럼 작동할 수 있습니다. ( -l 플래그의 출력은 너무 장황하므로 이 튜토리얼에서는 생략합니다.)

이제 필요한 것은 ls -l | sort -t _ -k 2 의 출력을 Emacs 버퍼에 캡처한 다음 dired-virtual-mode 을 활성화하는 것입니다. 이를 위해 M-x shell 또는 M-x eshell 을 사용한 다음 관련 내용을 수동으로 복사할 수 있습니다.

사용자의 편의를 위해 마지막 명령의 출력을 전용 버퍼에 빠르게 캡처할 수 있는 Eshell 의 기능을 공유합니다:

(defcustom prot-eshell-output-buffer "*Exported Eshell output*"
  "Name of buffer with the last output of Eshell command.
Used by `prot-eshell-export'."
  :type 'string
  :group 'prot-eshell)
 
(defcustom prot-eshell-output-delimiter "* * *"
  "Delimiter for successive `prot-eshell-export' outputs.
This is formatted internally to have newline characters before
and after it."
  :type 'string
  :group 'prot-eshell)
 
(defun prot-eshell--command-prompt-output ()
  "Capture last command prompt and its output."
  (let ((beg (save-excursion
               (goto-char (eshell-beginning-of-input))
               (goto-char (point-at-bol)))))
    (when (derived-mode-p 'eshell-mode)
      (buffer-substring-no-properties beg (eshell-end-of-output)))))
 
;;;###autoload
(defun prot-eshell-export ()
  "Produce a buffer with output of the last Eshell command.
If `prot-eshell-output-buffer' does not exist, create it.  Else
append to it, while separating multiple outputs with
`prot-eshell-output-delimiter'."
  (interactive)
  (let ((eshell-output (prot-eshell--command-prompt-output)))
    (with-current-buffer (get-buffer-create prot-eshell-output-buffer)
      (let ((inhibit-read-only t))
        (goto-char (point-max))
        (unless (eq (point-min) (point-max))
          (insert (format "\n%s\n\n" prot-eshell-output-delimiter)))
        (goto-char (point-at-bol))
        (insert eshell-output)
        (switch-to-buffer-other-window (current-buffer))))))

prot-eshell-export 를 eshell-mode-map 의 키에 바인딩하고 사용해 보세요(저는 C-c C-e 를 사용합니다). 생성된 버퍼에서 dired-virtual-mode 을 활성화합니다.

13.6. Use Embark to collect minibuffer candidates

Embark 사용하여 미니버퍼 후보 수집하기

embark 는 접두사 키를 사용하여 상황에 따라 관련성 있는 작업을 수행할 수 있는 놀라운 패키지입니다 (간결함을 위해 단순화했습니다).

저희의 경우, Embark 를 사용해 미니버퍼에서 바로 Dired 리스팅을 만들 수 있습니다. 현재 노트에 다른 노트 세 개에 대한 링크가 있다고 가정해 봅시다. denote-find-link 명령을 사용해 미니버퍼를 통해 하나를 선택할 수 있습니다. 하지만 이 세 개의 링크를 각각의 Dired 목록으로 바꾸면 어떨까요? 미니버퍼에 있는 동안 이미 C-. 에 바인딩되어 있을 수 있는 embark-act 를 호출한 다음, E ( embark-export 명령의 경우)로 이어서 호출합니다.

이 패턴은 모든 후보 목록에 대해 반복할 수 있으므로, Embark 로 결과를 내보내기 전에 몇 가지 입력을 제공하여 목록의 범위를 좁힐 수 있습니다.

전반적으로 이 기능은 매우 강력하며, 미니버퍼의 모든 기능을 활용할 수 있기 때문에 Dired 에서 직접 동일한 작업을 수행하는 것보다 선호할 수 있습니다(Dired 에서 파일 목록 좁히기).

---

embark is a remarkable package that lets you perform relevant, context-dependent actions using a prefix key (simplifying in the interest of brevity).

For our purposes, Embark can be used to produce a Dired listing directly from the minibuffer. Suppose the current note has links to three other notes. You might use the denote-find-link command to pick one via the minibuffer. But why not turn those three links into their own Dired listing? While in the minibuffer, invoke embark-act which you may have already bound to C-. and then follow it up with E (for the embark-export command).

This pattern can be repeated with any list of candidates, meaning that you can narrow the list by providing some input before eventually exporting the results with Embark.

Overall, this is very powerful and you might prefer it over doing the same thing directly in Dired, since you also benefit from all the power of the minibuffer ().

13.7. Search file contents

파일 내용 검색

Emacs 는 표준 유닉스 도구의 래퍼인 기본 제공 명령을 제공합니다. M-x grep 사용자는 grep 호출의 플래그를 입력하고 -e 플래그에 정규식을 전달할 수 있습니다.

Denote 의 저자는 이 얇은 래퍼를 대신 사용합니다:

(defvar prot-search--grep-hist '()
  "Input history of grep searches.")
 
;;;###autoload
(defun prot-search-grep (regexp &optional recursive)
  "Run grep for REGEXP.
 
Search in the current directory using `lgrep'.  With optional
prefix argument (\\[universal-argument]) for RECURSIVE, run a
search starting from the current directory with `rgrep'."
  (interactive
   (list
    (read-from-minibuffer (concat (if current-prefix-arg
                                      (propertize "Recursive" 'face 'warning)
                                    "Local")
                                  " grep for PATTERN: ")
                          nil nil nil 'prot-search--grep-hist)
    current-prefix-arg))
  (unless grep-command
    (grep-compute-defaults))
  (if recursive
      (rgrep regexp "*" default-directory)
    (lgrep regexp "*" default-directory)))

사용자 지정 코드를 유지 관리하는 대신 consult 패키지를 사용하는 것이 좋습니다. 패키지는 실시간 결과를 제공하고 일반적으로 기본 제공 명령보다 사용하기 쉬운 consult-grep 및 consult-find 등의 명령을 제공합니다.

13.8. Bookmark the directory with the notes

메모가 있는 디렉터리를 북마크에 추가하세요

Denote 가 기존 기능을 재창조하지 않는 이유 중 하나는 Emac 에 대해 더 많이 배우도록 장려하기 위해서입니다. "내 노트로 이동" 명령은 확장성이 좋지 않기 때문에 불필요 합니다. "내 다운로드로 이동"에 이어 멀티미디어 등을 위한 또 다른 "내 다운로드로 이동" 기능이 있나요? 아니요.

Emacs 에는 위치에 영구 마커를 기록하기 위한 프레임워크가 내장되어 있습니다. denote-directory (또는 해당 디렉터리/파일)을 방문하여 bookmark-set 명령(기본적으로 C-x r m 에 바인딩됨)을 실행합니다. 이 명령으로 북마크를 만들 수 있습니다.

북마크 목록은 bookmark-bmenu-list 명령(기본값은 C-x r l )으로 검토할 수 있습니다. 미니버퍼 인터페이스는 bookmark-jump ( C-x r b )에서 사용할 수 있습니다.

consult 패키지를 사용하는 경우 기본 consult-buffer 명령에는 버퍼, 최근 파일 및 북마크를 함께 그룹화할 수 있는 수단이 있습니다. 이러한 각 유형은 접두사 키를 사용하여 범위를 좁힐 수 있습니다. consult-dir 패키지는 consult 패키지를 확장한 것으로, 북마크를 포함한 디렉토리 작업에 유용한 추가 기능을 제공합니다.

13.9. Use the citar-denote package for bibliography notes

참고 문헌 노트에는 citar-denote 패키지 사용

Peter Prevos 는 citar-denote 패키지를 제작하여 citar 패키지의 도움으로 BibTeX 항목에 메모를 작성할 수 있게 해줍니다. 이러한 메모는 파일의 앞부분에 인용의 고유 키가 연결되어 있습니다. 또한 파일 이름에 구성 가능한 키워드를 지정할 수 있어 Dired 에서 쉽게 찾거나 다양한 Denote 메서드를 사용하여 검색할 수 있습니다.

citar-denote 를 통해 사용자는 표준 미니버퍼 완성 메커니즘(예: vertico 및 embark 패키지의 도움)을 활용해 서지 노트를 관리하고 해당 노트에 쉽게 액세스할 수 있습니다. 자세한 내용은 패키지 설명서를 참조하세요(https://github.com/pprevos/citar-denote/).

13.10. Use the consult-notes package

consult-notes 패키지 사용

다니엘 멘들러의 consult (훌륭한 패키지)를 사용 중이라면 콜린 맥리어가 개발한 consult-notes 확장 프로그램이 가장 마음에 드실 것입니다. 이 확장 프로그램은 익숙한 Consult 의 메커니즘을 사용하여 현재 선택된 항목을 미리 보고 접두사 키를 통해 검색을 필터링할 수 있습니다. 예를 들어

(setq consult-notes-file-dir-sources
      `(("Denote Notes"  ?d ,(denote-directory))
        ("Books"  ?b "~/Documents/books/")))

위와 같이 M-x consult-notes 을 입력하면 두 디렉터리에 있는 파일이 나열됩니다. d 를 입력하고 스페이스를 치면 노트만 목록이 좁혀지고 b 은 책의 경우와 동일합니다.

다른 접근 방식은 consult-notes-denote-mode 를 활성화하는 것입니다. consult-notes 이 읽어오는 소스에 denote-directory 을 추가하는 것입니다. 그런 다음 d 접두사 뒤에 공백을 붙여 노트를 필터링합니다.

마이너 모드에는 미니버퍼에 표시되는 노트 제목을 다시 포맷하는 추가 기능이 있습니다. 각 노트의 TITLE 구성요소를 분리해 하이픈 없이 표시하고, 키워드는 해당 열에 표시합니다. 사용자 옵션 consult-notes-denote-display-id 을 nil 으로 설정해 식별자를 숨길 수 있습니다. 노트를 검색하는 방식에 따라 이 개편된 프레젠테이션이 최선의 선택이 될 수도 있습니다(검색 또는 필터링을 위한 파일 명명 체계의 특징).

13.11. Use the denote-menu package

Denote 의 파일 이름 지정 체계는 효율적이고 파일에 대한 가치 있는 메타 정보를 제공하도록 설계되었습니다. 하지만 사용자가 노트를 필터링하고 처리하는 방식에 따라 간결하고 읽기 어렵다는 단점이 있습니다.

이를 위해 Mohamed Suliman 의 denote-menu 패키지는 모든 노트에 대해 멋진 표 형식의 인터페이스를 제공합니다. denote-menu 파일 이름에 있는 구분 기호를 제거하고 사람이 읽을 수 있는 형식으로 정보를 표시합니다. 또한, 이 패키지는 노트 목록과 상호 작용할 수 있는 명령어를 제공해 필터링과 표 형식의 목록에서 Dired 로 전환하는 등의 작업을 수행할 수 있습니다. 자세한 내용은 문서에서 확인할 수 있습니다.

13.12. Treat your notes as a project

노트를 프로젝트로 취급하기

Emacs 에는 디렉토리 트리를 "프로젝트"로 취급하는 라이브러리가 내장되어 있습니다. 즉, 이 트리의 콘텐츠는 동일한 세트의 일부로 간주되므로 project-switch-to-buffer (기본값은 C-x p b )와 같은 명령은 현재 프로젝트의 버퍼(예: 현재 방문 중인 노트 3 개)만 고려합니다.

일반적으로 "프로젝트"는 루트가 버전 관리 하에 있는 디렉토리 트리입니다. 여기서는 denote-directory (셸의 경우 또는 Dired 를 통해)로 이동하여 명령줄을 사용하여 실행하기만 하면 됩니다( git 실행 파일 필요):

git init

Dired 에서 dired-smart-shell-command 을 호출하는 M-! 을 입력한 다음 거기에서 git 호출을 실행할 수 있습니다.

그런 다음 프로젝트 내부에서 프로젝트 관련 명령(예: project-find-file ( C-x p f ))을 호출하여 프로젝트를 등록할 수 있습니다.

각 파일에 대한 변경 이력을 제공하기 때문에 버전 관리 하에 노트를 보관하는 것이 좋습니다. 여기서는 자세한 기술적인 내용은 다루지 않겠지만, Emacs 에 내장된 버전 관리 프레임워크나 매우 잘 만들어진 magit 패키지로도 충분히 작업을 수행할 수 있다는 점만 알아두세요(VC 는 Git 외에 다른 백엔드에서도 작동 가능).

13.13. Use the tree-based file prompt for select commands

선택 명령에 트리 기반 파일 프롬프트 사용

이전 버전의 Denote 에는 표준 find-file 명령(기본적으로 C-x C-f 에 바인딩됨)과 유사한 파일 프롬프트가 있었습니다. 즉, 특정 디렉터리를 선택한 다음 지정된 파일을 선택해 파일 시스템을 탐색하는 트리 기반 방법을 사용했습니다.

Currently, Denote flattens the file prompt so that every file in the denote-directory and its subdirectories can be matched from anywhere using the power of Emacs' minibuffer completion (such as with the help of the orderless package in addition to built-in options).

현재 Denote 는 파일 프롬프트를 평평하게 만들어 denote-directory 및 그 하위 디렉터리에 있는 모든 파일을 어디서든 Emac 의 미니버퍼 완성 기능(예: 기본 제공 옵션 외에 orderless 패키지의 도움)을 사용하여 일치시킬 수 있도록 합니다.

Users who need the old behaviour on a per-command basis can define their own wrapper functions as shown in the following code block.

명령별로 이전 동작이 필요한 사용자는 다음 코드 블록에 표시된 대로 자체 래퍼 함수를 정의할 수 있습니다.

;; This is the old `denote-file-prompt' that we renamed to
;; `denote-file-prompt-original' for clarity.
(defun denote-file-prompt-original (&optional initial-text)
  "Prompt for file with identifier in variable `denote-directory'.
With optional INITIAL-TEXT, use it to prepopulate the minibuffer."
  (read-file-name "Select note: " (denote-directory) nil nil initial-text
                  (lambda (f)
                    (or (denote-file-has-identifier-p f)
                        (file-directory-p f)))))
 
;; Our wrapper command that changes the current `denote-file-prompt'
;; to the functionality of `denote-file-prompt-original' only when
;; this command is used.
(defun my-denote-link ()
  "Call `denote-link' but use Denote's original file prompt.
See `denote-file-prompt-original'."
  (interactive)
  (cl-letf (((symbol-function 'denote-file-prompt) #'denote-file-prompt-original))
    (call-interactively #'denote-link)))

13.14. Rename files with Denote in the Image Dired thumbnails buffer

이미지 디렉터리 썸네일 버퍼에 표시를 사용하여 파일 이름 바꾸기

다음을 사용하여 Denote 로 파일 이름 바꾸기 dired-preview

denote-dired-rename-marked-files-with-keywords 에서와 마찬가지로 이미지 디렉터리 버퍼에서 Denote(한 번에 여러 파일 이름 바꾸기)를 사용할 수 있습니다. 다음은 사용자 정의 코드입니다:

(autoload 'image-dired--with-marked "image-dired")
(autoload 'image-dired-original-file-name "image-dired-util")
 
(defun my-denote-image-dired-rename-marked-files (keywords)
  "Like `denote-dired-rename-marked-files-with-keywords' but for Image Dired.
Prompt for KEYWORDS and rename all marked files in the Image
Dired buffer to have a Denote-style file name with the given
KEYWORDS.
 
IMPORTANT NOTE: if there are marked files in the corresponding
Dired buffers, those will be targeted as well.  This is not the
fault of Denote: it is how Dired and Image Dired work in tandem.
To only rename the marked thumbnails, start by unmarking
everything in Dired.  Then mark the items in Image Dired and
invoke this command."
  (interactive (list (denote-keywords-prompt)) image-dired-thumbnail-mode)
  (image-dired--with-marked
   (when-let* ((file (image-dired-original-file-name))
               (dir (file-name-directory file))
               (id (denote-retrieve-filename-identifier file))
               (file-type (denote-filetype-heuristics file))
               (title (denote--retrieve-title-or-filename file file-type))
               (extension (file-name-extension file t))
               (new-name (denote-format-file-name dir id keywords title extension))
               (default-directory dir))
     (denote-rename-file-and-buffer file new-name))))

While the my-denote-image-dired-rename-marked-files renames files in the helpful Denote-compliant way, users may still need to not prepend a unique identifier and not sluggify (hyphenate and downcase) the image's existing file name. To this end, the following custom command can be used instead:

my-denote-image-dired-rename-marked-files 은 유용한 Denote 호환 방식으로 파일 이름을 바꾸지만, 사용자는 여전히 고유 식별자를 앞에 붙이지 않고 이미지의 기존 파일 이름에 슬러그(하이픈 및 소문자)를 사용하지 않아야 할 수 있습니다. 이를 위해 다음 사용자 지정 명령을 대신 사용할 수 있습니다:

(defun my-image-dired-rename-marked-files (keywords)
  "Like `denote-dired-rename-marked-files-with-keywords' but for Image Dired.
Prompt for keywords and rename all marked files in the Image
Dired buffer to have Denote-style keywords, but none of the other
conventions of Denote's file-naming scheme."
  (interactive (list (denote-keywords-prompt)) image-dired-thumbnail-mode)
  (image-dired--with-marked
   (when-let* ((file (image-dired-original-file-name))
               (dir (file-name-directory file))
               (file-type (denote-filetype-heuristics file))
               (title (denote--retrieve-title-or-filename file file-type))
               (extension (file-name-extension file t))
               (kws (denote--keywords-combine keywords))
               (new-name (concat dir title "__" kws extension))
               (default-directory dir))
     (denote-rename-file-and-buffer file new-name))))

13.15. Rename files with Denote using dired-preview

다음을 사용하여 Denote 로 파일 이름 바꾸기 dired-preview

The dired-preview package (by me/Protesilaos) automatically displays a preview of the file at point in Dired. This can be helpful in tandem with Denote when we want to rename multiple files by taking a quick look at their contents.

dired-preview 패키지(저/프로테실라오스 작성)는 Dired 의 특정 지점에서 파일의 미리보기를 자동으로 표시합니다. 이 기능은 여러 파일의 내용을 빠르게 살펴보고 이름을 바꾸고 싶을 때 Denote 와 함께 사용하면 유용합니다.

The command denote-dired-rename-marked-files-with-keywords will generate Denote-style file names based on the keywords it prompts for. Identifiers are derived from each file's modification date (). There is no need for any custom code in this scenario.

denote-dired-rename-marked-files-with-keywords 명령은 입력하라는 키워드에 따라 Denote 스타일의 파일 이름을 생성합니다. 식별자는 각 파일의 수정 날짜에서 파생됩니다(한 번에 여러 파일 이름 바꾸기). 이 시나리오에서는 사용자 지정 코드가 필요하지 않습니다.

As noted in the section about Image Dired, the user may sometimes not need a fully fledged Denote-style file name but only append Denote-like keywords to each file name (e.g. Original Name__denote_test.jpg instead of 20230710T195843--original-name__denote_test.jpg).

이미지 디어드에 대한 섹션에서 언급했듯이, 사용자는 때때로 완전한 Denote 스타일의 파일 이름이 필요하지 않고 각 파일 이름에 Denote 와 유사한 키워드만 추가할 수 있습니다(예: 20230710T195843--original-name__denote_test.jpg 대신 Original Name__denote_test.jpg ).

[[#h:e666ced6-da75-4bdb-9be3-82c2f4455ee9][Rename files with Denote in the Image Dired thumbnails buffer

이미지 축소판 버퍼에 표시를 사용하여 파일 이름 바꾸기]]

In such a workflow, it is unlikely to be dealing with ordinary text files where front matter can be helpful. A custom command does not need to behave like what Denote provides out-of-the-box, but can instead append keywords to file names without conducting any further actions. We thus have:

이러한 워크플로에서는 앞부분이 도움이 될 수 있는 일반 텍스트 파일을 다루는 경우는 거의 없을 것입니다. 사용자 지정 명령은 Denote 가 기본으로 제공하는 것과 같이 작동할 필요가 없으며, 대신 추가 작업 없이 파일 이름에 키워드를 추가할 수 있습니다. 따라서

(defun my-denote-dired-rename-marked-files-keywords-only ()
  "Like `denote-dired-rename-marked-files-with-keywords' but only for keywords in file names.
 
Prompt for keywords and rename all marked files in the Dired
buffer to only have Denote-style keywords, but none of the other
conventions of Denote's file-naming scheme."
  (interactive nil dired-mode)
  (if-let ((marks (dired-get-marked-files)))
      (let ((keywords (denote-keywords-prompt)))
        (dolist (file marks)
          (let* ((dir (file-name-directory file))
                 (file-type (denote-filetype-heuristics file))
                 (title (denote--retrieve-title-or-filename file file-type))
                 (extension (file-name-extension file t))
                 (kws (denote--keywords-combine keywords))
                 (new-name (concat dir title "__" kws extension)))
            (denote-rename-file-and-buffer file new-name)))
        (revert-buffer))
    (user-error "No marked files; aborting")))

13.16. Avoid duplicate identifiers when exporting Denote notes

Denote 노트를 내보낼 때 중복 식별자 피하기

When exporting Denote notes to, for example, an HTML or PDF file, there is a high probability that the same file name is used with a new extension. This is problematic because it creates files with duplicate identifiers. The 20230515T085612--example__keyword.org produces a 20230515T085612--example__keyword.pdf. Any link to the 20230515T085612 will thus break: it does not honor Denote's expectation of finding unique identifiers. This is not the fault of Denote: exporting is done by the user without Denote's involvement.

예를 들어, Denote 노트를 HTML 이나 PDF 파일로 내보낼 때, 동일한 파일 이름이 새 확장명과 함께 사용될 가능성이 높습니다. 이는 중복 식별자를 가진 파일을 생성하기 때문에 문제가 됩니다. 20230515T085612--example__keyword.org 은 20230515T085612--example__keyword.pdf 을 생성합니다. 따라서 20230515T085612 로 연결되는 모든 링크는 고유 식별자를 찾으려는 Denote 의 기대에 부합하지 않습니다. 이는 Denote 의 잘못이 아닙니다. 내보내기는 Denote 의 개입 없이 사용자가 수행합니다.

Org Mode and Markdown use different approaches to exporting files. No recommended method is available for plain text files as there is no standardised export functionality for this format (the user can always create a new note using the file type they want on a case-by-case basis: ).

조직 모드와 마크다운은 파일 내보내기에 서로 다른 방식을 사용합니다. 일반 텍스트 파일은 이 형식에 대한 표준화된 내보내기 기능이 없기 때문에 권장되는 방법이 없습니다(사용자는 언제나 케이스별로 원하는 파일 형식을 사용해 새 노트를 만들 수 있습니다): 노트 생성을 위한 편리한 명령어).

13.16.1. Export Denote notes with Org Mode

조직 모드로 노트 표시 내보내기

Org Mode has a built-in configurable export engine. You can prevent duplicate identifiers when exporting manually for each exported file or by advising the Org export function.

조직 모드에는 구성 가능한 내보내기 엔진이 내장되어 있습니다. 내보내는 각 파일에 대해 수동으로 내보낼 때 또는 조직 내보내기 기능을 알려주면 중복 식별자를 방지할 수 있습니다.

13.16.1.1. Manually configure Org export

13.16.1.1. 조직 내보내기 수동 구성

Insert #+export_file_name: FILENAME in the front matter before exporting to force a filename called whatever the value of FILENAME is. The FILENAME does not specify the file type extension, such as .pdf. This is up to the export engine. For example, a Denote note with a complete file name of 20230515T085612--example__keyword.org and a front matter entry of #+export_file_name: hello will be exported as hello.pdf.

내보내기 전에 앞머리에 #+export_file_name: FILENAME 을 삽입하면 FILENAME 값과 같은 파일 이름이 강제로 지정됩니다. FILENAME 은 .pdf 과 같은 파일 형식 확장자를 지정하지 않습니다. 이는 내보내기 엔진에 달려 있습니다. 예를 들어, 전체 파일명이 20230515T085612--example__keyword.org 이고 앞머리 항목이 #+export_file_name: hello 인 Denote 노트는 hello.pdf 로 내보내집니다.

The advantage of this manual method is that it gives the user full control over the resulting file name. The disadvantage is that it depends on the user's behaviour. Forgetting to add a new name can lead to duplicate identifiers, as already noted in the introduction to this section ().

이 수동 방법의 장점은 사용자가 결과 파일 이름을 완전히 제어할 수 있다는 것입니다. 단점은 사용자의 행동에 따라 달라진다는 것입니다. 새 이름을 추가하는 것을 잊어버리면 이 섹션의 소개에서 이미 언급했듯이 식별자가 중복될 수 있습니다(내보내기 표시 노트).

13.16.1.2. Automatically store Org exports in another folder

13.16.1.2. 조직 내보내기를 다른 폴더에 자동으로 저장하기

It is possible to automatically place all exports in another folder by making Org's function org-export-output-file-name create the target directory if needed and move the exported file there. Remember that advising Elisp code must be handled with care, as it might break the original function in subtle ways.

필요한 경우 조직의 함수 org-export-output-file-name 가 대상 디렉터리를 생성하고 내보낸 파일을 해당 디렉터리로 이동하도록 하여 모든 내보낸 파일을 다른 폴더에 자동으로 배치할 수 있습니다. Elisp 코드를 조언하는 것은 미묘한 방식으로 원래 기능을 손상시킬 수 있으므로 신중하게 처리해야 합니다.

(defvar my-org-export-output-directory-prefix "./export_"
  "Prefix of directory used for org-mode export.
 
The single dot means that the directory is created on the same
level as the one where the Org file that performs the exporting
is.  Use two dots to place the directory on a level above the
current one.
 
If this directory is part of `denote-directory', make sure it is
not read by Denote.  See `denote-excluded-directories-regexp'.
This way there will be no known duplicate Denote identifiers
produced by the Org export mechanism.")
 
(defun my-org-export-create-directory (fn extension &rest args)
  "Move Org export file to its appropriate directory.
 
Append the file type EXTENSION of the exported file to
`my-org-export-output-directory-prefix' and, if absent, create a
directory named accordingly.
 
Install this as advice around `org-export-output-file-name'.  The
EXTENSION is supplied by that function.  ARGS are its remaining
arguments."
  (let ((export-dir (format "%s%s" my-org-export-output-directory-prefix extension)))
    (unless (file-directory-p export-dir)
      (make-directory export-dir)))
  (apply fn extension args))
 
(advice-add #'org-export-output-file-name :around #'my-org-export-create-directory)

The target export directory should not be a subdirectory of denote-directory, as that will result in duplicate identifiers. Exclude it with the denote-excluded-directories-regexp user option ().

대상 내보내기 디렉터리는 denote-directory 의 하위 디렉터리가 아니어야 합니다. 중복 식별자가 발생하기 때문입니다. denote-excluded-directories-regexp 사용자 옵션(모든 작업에서 특정 디렉터리 제외)을 사용하여 제외합니다.

[ NOTE: I (Protesilaos) am not a LaTeX user and cannot test the following. ]

[참고: 본(Protesilaos)은 LaTeX 사용자가 아니므로 다음을 테스트할 수 없습니다.]

Using a different directory will require some additional configuration when exporting using LaTeX. The export folder cannot be inside the path of the denote-directory to prevent Denote from recognising it as an attachment: https://emacs.stackexchange.com/questions/45751/org-export-to-different-directory.

다른 디렉터리를 사용하려면 LaTeX 를 사용하여 내보낼 때 몇 가지 추가 구성이 필요합니다. 내보내기 폴더가 denote-directory 경로 내에 있으면 Denote 에서 첨부 파일로 인식하지 못합니다(https://emacs.stackexchange.com/questions/45751/org-export-to-different-directory).

13.16.1.3. Org Mode Publishing

13.16.1.3. 조직 모드 게시

Org Mode also has a publishing tool for exporting a collection of files. Some user might apply this approach to convert their note collection to a public or private website.

조직 모드에는 파일 컬렉션을 내보내기 위한 게시 도구도 있습니다. 일부 사용자는 이 방법을 사용해 노트 컬렉션을 공개 또는 비공개 웹사이트로 전환할 수 있습니다.

The org-publish-project-alist variable drives the publishing process, including the publishing directory.

org-publish-project-alist 변수는 게시 디렉터리를 포함하여 게시 프로세스를 구동합니다.

The publishing directory should not be a subdirectory of denote-directory, as that will result in duplicate identifiers. Exclude it with the denote-excluded-directories-regexp user option ().

게시 디렉터리는 denote-directory 의 하위 디렉터리가 되어서는 안 되며, 중복 식별자가 발생하기 때문입니다. denote-excluded-directories-regexp 사용자 옵션(모든 작업에서 특정 디렉터리 제외)을 사용하여 제외합니다.

13.16.2. Export Denote notes with Markdown

13.16.2. 마크다운으로 노트 표시 내보내기

Exporting from Markdown requires an external processor (e.g., Markdown.pl, Pandoc, or MultiMarkdown). The markdown-command variable defines the command line used in export, for example:

Markdown 에서 내보내려면 외부 프로세서(예: Markdown.pl, Pandoc 또는 MultiMarkdown)가 필요합니다. 예를 들어 markdown-command 변수는 내보내기에 사용되는 명령줄을 정의합니다:

(setq markdown-command "multimarkdown")

The export process thus occurs outside of Emacs. Users need to read the documentation of their preferred processor to prevent the creation of duplicate Denote identifiers.

따라서 내보내기 프로세스는 Emacs 외부에서 이루어집니다. 사용자는 선호하는 프로세서의 설명서를 읽고 중복된 Denote 식별자가 생성되는 것을 방지해야 합니다.

14. Installation

14.1. GNU ELPA package14.1. GNU ELPA 패키지

The package is available as denote. Simply do:

패키지는 denote 으로 제공됩니다. 간단히 하세요:

M-x package-refresh-contents
M-x package-install

And search for it.

그리고 검색하세요.

GNU ELPA provides the latest stable release. Those who prefer to follow the development process in order to report bugs or suggest changes, can use the version of the package from the GNU-devel ELPA archive. Read: https://protesilaos.com/codelog/2022-05-13-emacs-elpa-devel/.

GNU ELPA 는 최신 안정 릴리스를 제공합니다. 버그를 보고하거나 변경 사항을 제안하기 위해 개발 프로세스를 따르는 것을 선호하는 사용자는 GNU-devel ELPA 아카이브에서 패키지 버전을 사용할 수 있습니다. 참조: https://protesilaos.com/codelog/2022-05-13-emacs-elpa-devel/.

14.2. Manual installation

14.2. 수동 설치

Assuming your Emacs files are found in ~/.emacs.d/, execute the following commands in a shell prompt:

Emacs 파일이 ~/.emacs.d/ 에 있다고 가정하고 셸 프롬프트에서 다음 명령을 실행합니다:

cd ~/.emacs.d
 
# Create a directory for manually-installed packages
mkdir manual-packages
 
# Go to the new directory
cd manual-packages
 
# Clone this repo, naming it "denote"
git clone https://git.sr.ht/~protesilaos/denote denote

Finally, in your init.el (or equivalent) evaluate this:

마지막으로 init.el (또는 이에 상응하는 항목)에서 이를 평가합니다:

;; Make Elisp files in that directory available to the user.
(add-to-list 'load-path "~/.emacs.d/manual-packages/denote")

Everything is in place to set up the package.

패키지 설정을 위한 모든 준비가 완료되었습니다.

REVIEW 15. Sample configuration15. 샘플 구성

(require 'denote)
 
;; Remember to check the doc strings of those variables.
(setq denote-directory (expand-file-name "~/Documents/notes/"))
(setq denote-known-keywords '("emacs" "philosophy" "politics" "economics"))
(setq denote-infer-keywords t)
(setq denote-sort-keywords t)
(setq denote-file-type nil) ; Org is the default, set others here
(setq denote-prompts '(title keywords))
(setq denote-excluded-directories-regexp nil)
(setq denote-excluded-keywords-regexp nil)
 
;; Pick dates, where relevant, with Org's advanced interface:
(setq denote-date-prompt-use-org-read-date t)
 
 
;; Read this manual for how to specify `denote-templates'.  We do not
;; include an example here to avoid potential confusion.
 
 
(setq denote-date-format nil) ; read doc string
 
;; By default, we do not show the context of links.  We just display
;; file names.  This provides a more informative view.
(setq denote-backlinks-show-context t)
 
;; Also see `denote-link-backlinks-display-buffer-action' which is a bit
;; advanced.
 
;; If you use Markdown or plain text files (Org renders links as buttons
;; right away)
(add-hook 'find-file-hook #'denote-link-buttonize-buffer)
 
;; We use different ways to specify a path for demo purposes.
(setq denote-dired-directories
      (list denote-directory
            (thread-last denote-directory (expand-file-name "attachments"))
            (expand-file-name "~/Documents/books")))
 
;; Generic (great if you rename files Denote-style in lots of places):
;; (add-hook 'dired-mode-hook #'denote-dired-mode)
;;
;; OR if only want it in `denote-dired-directories':
(add-hook 'dired-mode-hook #'denote-dired-mode-in-directories)
 
 
;; Automatically rename Denote buffers using the `denote-rename-buffer-format'.
(denote-rename-buffer-mode 1)
 
;; Denote DOES NOT define any key bindings.  This is for the user to
;; decide.  For example:
(let ((map global-map))
  (define-key map (kbd "C-c n n") #'denote)
  (define-key map (kbd "C-c n c") #'denote-region) ; "contents" mnemonic
  (define-key map (kbd "C-c n N") #'denote-type)
  (define-key map (kbd "C-c n d") #'denote-date)
  (define-key map (kbd "C-c n z") #'denote-signature) ; "zettelkasten" mnemonic
  (define-key map (kbd "C-c n s") #'denote-subdirectory)
  (define-key map (kbd "C-c n t") #'denote-template)
  ;; If you intend to use Denote with a variety of file types, it is
  ;; easier to bind the link-related commands to the `global-map', as
  ;; shown here.  Otherwise follow the same pattern for `org-mode-map',
  ;; `markdown-mode-map', and/or `text-mode-map'.
  (define-key map (kbd "C-c n i") #'denote-link) ; "insert" mnemonic
  (define-key map (kbd "C-c n I") #'denote-add-links)
  (define-key map (kbd "C-c n b") #'denote-backlinks)
  (define-key map (kbd "C-c n f f") #'denote-find-link)
  (define-key map (kbd "C-c n f b") #'denote-find-backlink)
  ;; Note that `denote-rename-file' can work from any context, not just
  ;; Dired bufffers.  That is why we bind it here to the `global-map'.
  (define-key map (kbd "C-c n r") #'denote-rename-file)
  (define-key map (kbd "C-c n R") #'denote-rename-file-using-front-matter))
 
;; Key bindings specifically for Dired.
(let ((map dired-mode-map))
  (define-key map (kbd "C-c C-d C-i") #'denote-link-dired-marked-notes)
  (define-key map (kbd "C-c C-d C-r") #'denote-dired-rename-files)
  (define-key map (kbd "C-c C-d C-k") #'denote-dired-rename-marked-files-with-keywords)
  (define-key map (kbd "C-c C-d C-R") #'denote-dired-rename-marked-files-using-front-matter))
 
(with-eval-after-load 'org-capture
  (setq denote-org-capture-specifiers "%l\n%i\n%?")
  (add-to-list 'org-capture-templates
               '("n" "New note (with denote.el)" plain
                 (file denote-last-path)
                 #'denote-org-capture
                 :no-save t
                 :immediate-finish nil
                 :kill-buffer t
                 :jump-to-captured t)))
 
;; Also check the commands `denote-link-after-creating',
;; `denote-link-or-create'.  You may want to bind them to keys as well.
 
 
;; If you want to have Denote commands available via a right click
;; context menu, use the following and then enable
;; `context-menu-mode'.
(add-hook 'context-menu-functions #'denote-context-menu)

16. For developers or advanced users

개발자 또는 고급 사용자용

Denote is in a stable state and can be relied upon as the basis for custom extensions. Further below is a list with the functions or variables we provide for public usage. Those are in addition to all user options and commands that are already documented in the various sections of this manual.

Denote 는 안정적인 상태이며 사용자 정의 확장을 위한 기초로 신뢰할 수 있습니다. 아래는 공개적으로 사용할 수 있도록 제공하는 함수 또는 변수의 목록입니다. 이 목록은 이 매뉴얼의 여러 섹션에 이미 설명되어 있는 모든 사용자 옵션과 명령어에 추가됩니다.

In this context “public” is any form with single hyphens in its symbol, such as denote-directory-files. We expressly support those, meaning that we consider them reliable and commit to documenting any changes in their particularities (such as through make-obsolete, a record in the change log, a blog post on the maintainer's website, and the like).

여기서 '공개'는 denote-directory-files 와 같이 기호에 하이픈이 하나 포함된 모든 형태를 의미합니다. 트위터는 이를 명시적으로 지원하며, 이는 트위터가 이를 신뢰할 수 있는 것으로 간주하고 변경 사항을 문서화할 것을 약속한다는 의미입니다(예: make-obsolete , 변경 로그의 기록, 유지 관리자의 웹사이트에 있는 블로그 게시물 등).

By contradistinction, a “private” form is declared with two hyphens in its symbol such as denote--file-extension. Do not use those as we might change them without further notice.

이와는 반대로 '비공개' 양식은 denote--file-extension 과 같이 기호에 하이픈 두 개를 사용하여 선언됩니다. 트위터에서 별도의 통지 없이 변경할 수 있으므로 사용하지 마세요.

Variable denote-id-format변수 denote-id-format : Format of ID prefix of a note's filename. The note's ID is derived from the date and time of its creation ().

노트 파일 이름의 ID 접두사 형식입니다. 노트의 ID 는 노트가 생성된 날짜와 시간(파일 명명 체계)에서 파생됩니다.

Variable denote-id-regexp변수 denote-id-regexp : Regular expression to match denote-id-format.

일치할 정규식 `denote-id-format` .

Variable denote-signature-regexp변수 denote-signature-regexp :: Regular expression to match the SIGNATURE field in a file name.

파일 이름의 `SIGNATURE` 필드와 일치하는 정규식입니다.

Variable denote-title-regexp변수 denote-title-regexp : Regular expression to match the TITLE field in a file name ().

파일 이름의 `TITLE` 필드와 일치하는 정규식(파일 이름 지정 체계)입니다.

Variable denote-keywords-regexp변수 denote-keywords-regexp :: Regular expression to match the KEYWORDS field in a file name ().

파일 이름의 `KEYWORDS` 필드와 일치하는 정규식(파일 이름 지정 체계)입니다.

Variable denote-excluded-punctuation-regexp변수 denote-excluded-punctuation-regexp :: Punctionation that is removed from file names. We consider those characters illegal for our purposes.

파일 이름에서 제거되는 문장 부호. 트위터에서는 이러한 문자를 불법으로 간주합니다.

Variable denote-excluded-punctuation-extra-regexp변수 denote-excluded-punctuation-extra-regexp :: Additional punctuation that is removed from file names. This variable is for advanced users who need to extend the denote-excluded-punctuation-regexp. Once we have a better understanding of what we should be omitting, we will update things accordingly.

파일 이름에서 제거되는 추가 구두점입니다. 이 변수는 `denote-excluded-punctuation-regexp` 을 확장해야 하는 고급 사용자를 위한 변수입니다. 무엇을 생략해야 하는지 더 잘 이해하게 되면 그에 따라 업데이트할 예정입니다.

Function denote-file-is-note-p기능 denote-file-is-note-p :: Return non-nil if FILE is an actual Denote note. For our purposes, a note must not be a directory, must satisfy file-regular-p, its path must be part of the variable denote-directory, it must have a Denote identifier in its name, and use one of the extensions implied by denote-file-type.

`FILE` 가 실제 Denote 노트인 경우 nil 이 아닌 값을 반환합니다. 저희의 목적상, 노트는 디렉터리가 아니어야 하고, `file-regular-p` 를 만족해야 하며, 경로가 `denote-directory` 변수의 일부여야 하고, 이름에 Denote 식별자가 있어야 하고, `denote-file-type` 에 암시된 확장자 중 하나를 사용해야 합니다.

Function denote-file-has-identifier-p기능 denote-file-has-identifier-p :: Return non-nil if FILE has a Denote identifier.

`FILE` 에 Denote 식별자가 있는 경우 nil 이 아닌 값을 반환합니다.

Function denote-file-has-signature-p기능 denote-file-has-signature-p :: Return non-nil if FILE has a signature.

`FILE` 에 서명이 있는 경우 null 을 반환합니다.

Function denote-file-has-supported-extension-p기능 denote-file-has-supported-extension-p :: Return non-nil if FILE has supported extension. Also account for the possibility of an added .gpg suffix. Supported extensions are those implied by denote-file-type.

`FILE` 확장자가 지원되는 경우 nil 을 반환합니다. `.gpg` 접미사가 추가될 가능성도 고려합니다. 지원되는 확장자는 `denote-file-type` 에 의해 암시되는 확장자입니다.

Function denote-file-is-writable-and-supported-p기능 denote-file-is-writable-and-supported-p :: Return non-nil if FILE is writable and has supported extension.

`FILE` 에 쓰기 가능하고 지원되는 확장자가 있으면 null 을 반환합니다.

Function denote-file-type-extensions기능 denote-file-type-extensions :: Return all file type extensions in denote-file-types.

`denote-file-types` 에서 모든 파일 형식 확장자를 반환합니다.

Variable denote-encryption-file-extensions변수 denote-encryption-file-extensions :: List of strings specifying file extensions for encryption.

암호화를 위한 파일 확장명을 지정하는 문자열 목록입니다.

Function denote-file-type-extensions-with-encryption기능 denote-file-type-extensions-with-encryption :: Derive denote-file-type-extensions plus denote-encryption-file-extensions.

파생 `denote-file-type-extensions` + `denote-encryption-file-extensions` .

Function denote-get-file-extension기능 denote-get-file-extension :: Return extension of FILE with dot included. Account for denote-encryption-file-extensions. In other words, return something like .org.gpg if it is part of the file, else return .org. [ Part of 2.1.0-dev. ]

반환 확장자는 `FILE` (점 포함)입니다. `denote-encryption-file-extensions` 을 반환합니다. 즉, 파일의 일부인 경우 `.org.gpg` 와 같은 것을 반환하고, 그렇지 않으면 `.org` 을 반환합니다. [ 2.1.0-dev. 의 일부 ]입니다.

Function denote-get-file-extension-sans-encryption기능 denote-get-file-extension-sans-encryption :: Return extension of FILE with dot included and without the encryption part. Build on top of denote-get-file-extension though always return something like .org even if the actual file extension is .org.gpg. [ Part of 2.1.0-dev. ]

점 포함 및 암호화 부분 없이 `FILE` 의 확장자를 반환합니다. 실제 파일 확장자가 `.org.gpg` 이더라도 항상 `.org` 과 같은 것을 반환하지만 `denote-get-file-extension` 을 기반으로 빌드합니다. [ 2.1.0-dev. 의 일부 ]입니다.

Function denote-keywords기능 denote-keywords : Return appropriate list of keyword candidates. If denote-infer-keywords is non-nil, infer keywords from existing notes and combine them into a list with denote-known-keywords. Else use only the latter set of keywords ().

적절한 키워드 후보 목록을 반환합니다. `denote-infer-keywords` 가 0 이 아닌 경우, 기존 노트에서 키워드를 유추해 `denote-known-keywords` 와 함께 목록으로 결합합니다. 그렇지 않으면 후자의 키워드 세트만 사용합니다( 표준 노트 만들기).

Function denote-keywords-sort기능 denote-keywords-sort : Sort KEYWORDS if denote-sort-keywords is non-nil. KEYWORDS is a list of strings, per denote-keywords-prompt.

`denote-sort-keywords` 이 nil 이 아닌 경우 `KEYWORDS` 을 정렬합니다. `KEYWORDS` 은 `denote-keywords-prompt` 에 따른 문자열 목록입니다.

Function denote-keywords-combine기능 denote-keywords-combine :: Combine KEYWORDS list of strings into a single string. Keywords are separated by the underscore character, per the Denote file-naming scheme. [ Made public as part of 2.1.0-dev. ]

`KEYWORDS` 문자열 목록을 하나의 문자열로 결합합니다. 키워드는 파일 이름 지정 체계에 따라 밑줄 문자로 구분됩니다. [ 2.1.0-dev 의 일부로 공개됨 ].

Function denote-directory기능 denote-directory : Return path of the variable denote-directory as a proper directory, also because it accepts a directory-local value for what we internally refer to as “silos” (). Custom Lisp code can let bind the value of the variable denote-user-enforced-denote-directory to override what this function returns.

`denote-directory` 변수의 반환 경로는 적절한 디렉터리로, 내부적으로 "사일로"라고 부르는 것에 대한 디렉터리 로컬 값을 허용하기 때문입니다(노트에 대해 별도의 디렉터리를 유지하세요). 사용자 정의 Lisp 코드는 `let` `denote-user-enforced-denote-directory` 변수의 값을 바인딩하여 이 함수가 반환하는 내용을 재정의할 수 있습니다.

Function denote-directory-files기능 denote-directory-files :: Return list of absolute file paths in variable denote-directory. Files only need to have an identifier. The return value may thus include file types that are not implied by denote-file-type. To limit the return value to text files, use the function denote-directory-text-only-files. Remember that the denote-directory accepts a directory-local value ().

변수에 절대 파일 경로 목록을 반환합니다 `denote-directory` . 파일에는 식별자만 있으면 됩니다. 따라서 반환 값에는 `denote-file-type` 에 암시되지 않은 파일 유형이 포함될 수 있습니다. 반환값을 텍스트 파일로 제한하려면 `denote-directory-text-only-files` 함수를 사용하세요. `denote-directory` 은 디렉터리-로컬 값을 허용한다는 점을 기억하세요(노트에 대해 별도의 디렉터리를 유지하세요).

Function denote-directory-text-only-files기능 denote-directory-text-only-files :: Return list of text files in variable denote-directory. Filter denote-directory-files using denote-file-is-note-p.

변수에 텍스트 파일 목록을 반환합니다 `denote-directory` . `denote-file-is-note-p` 을 사용하여 `denote-directory-files` 필터링합니다.

Function denote-directory-subdirectories기능 denote-directory-subdirectories :: Return list of subdirectories in variable denote-directory. Omit dotfiles (such as .git) unconditionally. Also exclude whatever matches denote-excluded-directories-regexp. Note that the denote-directory accepts a directory-local value for what we call “silos” ().

변수에 있는 하위 디렉터리 목록을 반환합니다 `denote-directory` . 닷파일(예: .git)은 무조건 생략합니다. 또한 `denote-excluded-directories-regexp` 과 일치하는 것은 모두 제외합니다. `denote-directory` 은 "사일로"라고 부르는 디렉터리-로컬 값을 허용합니다(노트에 대해 별도의 디렉터리를 유지하세요).

Function denote-directory-files-matching-regexp기능 denote-directory-files-matching-regexp :: Return list of files matching REGEXP in denote-directory-files.

`denote-directory-files` 에서 `REGEXP` 과 일치하는 파일 목록을 반환합니다.

Function denote-all-files기능 denote-all-files : Return the list of Denote files in the variable denote-directory. With optional OMIT-CURRENT, do not include the current Denote file in the returned list. [ The OMIT-CURRENT is part of 2.1.0-dev. ]

변수에 Denote 파일 목록을 반환합니다 `denote-directory` . 선택 사항으로 `OMIT-CURRENT` 를 사용하면 반환된 목록에 현재 Denote 파일을 포함하지 않습니다. [ `OMIT-CURRENT` 은 2.1.0-dev 의 일부입니다.]

Function denote-file-name-relative-to-denote-directory기능 denote-file-name-relative-to-denote-directory :: Return name of FILE relative to the variable denote-directory. FILE must be an absolute path.

변수 `denote-directory` 에 상대적인 `FILE` 의 반환 이름 `FILE` 은 절대 경로여야 합니다.

Function denote-get-path-by-id기능 denote-get-path-by-id :: Return absolute path of ID string in denote-directory-files.

`denote-directory-files` 에서 `ID` 문자열의 절대 경로를 반환합니다.

Function denote-barf-duplicate-id기능 denote-barf-duplicate-id :: Throw a user-error if IDENTIFIER already exists.

`IDENTIFIER` 이 이미 존재하는 경우 `user-error` 을 던집니다.

Function denote-sluggify기능 denote-sluggify : Make STR an appropriate slug for file names and related ().

`STR` 을 파일 이름 및 관련(슬러그화된 제목 및 키워드)에 적합한 슬러그로 만듭니다.

Function denote-sluggify-and-join기능 denote-sluggify-and-join :: Sluggify STR while joining separate words.

별도의 단어를 연결하면서 `STR` .

Function denote-desluggify기능 denote-desluggify : Upcase first char in STR and dehyphenate STR, inverting denote-sluggify. Basically, convert this-is-a-test to This is a test.

`STR` 의 첫 번째 문자를 대문자로 바꾸고 `STR` 을 하이픈으로 바꾸고 `denote-sluggify` 을 반전시킵니다. 기본적으로 `this-is-a-test` 를 `This is a test` 로 변환합니다.

Function denote-sluggify-signature기능 denote-sluggify-signature :: Make STR an appropriate slug for signatures ().

`STR` 을 서명에 적합한 슬러그로 설정합니다(파일 이름의 대소문자 구분).

Function denote-sluggify-keywords기능 denote-sluggify-keywords :: Sluggify KEYWORDS, which is a list of strings ().

Sluggify `KEYWORDS` , 문자열 목록입니다(슬러그화된 제목 및 키워드).

Function denote-filetype-heuristics기능 denote-filetype-heuristics :: Return likely file type of FILE. Use the file extension to detect the file type of the file.

`FILE` 의 유력한 파일 유형을 반환합니다. 파일 확장자를 사용하여 파일의 파일 유형을 감지합니다.

If more than one file type correspond to this file extension, use the first file type for which the key-title-kegexp matches in the file or, if none matches, use the first type with this file extension in `denote-file-type`.

이 파일 확장자에 해당하는 파일 형식이 두 개 이상인 경우 파일에서 key-title-kegexp 가 일치하는 첫 번째 파일 형식을 사용하거나, 일치하는 형식이 없는 경우 `denote-file-type` 에서 이 파일 확장자를 가진 첫 번째 형식을 사용하세요.

If no file types in `denote-file-types` has the file extension, the file type is assumed to be the first of `denote-file-types`.

`denote-file-types` 에 파일 확장자가 없는 파일 형식은 `denote-file-types` 의 첫 번째 파일 형식인 것으로 가정합니다.

Function denote-format-file-name기능 denote-format-file-name :: Format file name. PATH, ID, KEYWORDS, TITLE-SLUG are expected to be supplied by denote or equivalent: they will all be converted into a single string. EXTENSION is the file type extension, as a string.

형식 파일 이름. `PATH` , `ID` , `KEYWORDS` , `TITLE-SLUG` 은 `denote` 또는 이와 동등한 형식으로 제공되어야 하며, 모두 단일 문자열로 변환됩니다. `EXTENSION` 은 파일 형식 확장자로, 문자열로 제공됩니다.

Function denote-extract-keywords-from-path기능 denote-extract-keywords-from-path :: Extract keywords from PATH and return them as a list of strings. PATH must be a Denote-style file name where keywords are prefixed with an underscore. If PATH has no such keywords, which is possible, return nil ().

`PATH` 에서 키워드를 추출하여 문자열 목록으로 반환합니다. `PATH` 은 키워드 앞에 밑줄이 붙은 Denote 스타일의 파일 이름이어야 합니다. `PATH` 에 이러한 키워드가 없는 경우 nil(파일 이름 지정 체계)을 반환합니다.

Function denote-extract-id-from-string기능 denote-extract-id-from-string :: Return existing Denote identifier in STRING, else nil.

`STRING` 에서 기존 식별자를 반환하고 그렇지 않으면 nil 을 반환합니다.

Function denote-retrieve-filename-identifier기능 denote-retrieve-filename-identifier :: Extract identifier from FILE name. To create a new one, refer to the denote-create-unique-file-identifier function.

`FILE` 이름에서 식별자를 추출합니다. 새로 만들려면 `denote-create-unique-file-identifier` 함수를 참조하세요.

Function denote-retrieve-filename-signature기능 denote-retrieve-filename-signature :: Extract signature from FILE name, if present, else return nil.

`FILE` 이름에서 서명을 추출합니다(있는 경우), 그렇지 않으면 nil 을 반환합니다.

Function denote-create-unique-file-identifier기능 denote-create-unique-file-identifier :: Create a new unique FILE identifier. Test that the identifier is unique among USED-IDS. The conditions are as follows:

고유한 `FILE` 식별자를 새로 만듭니다. 식별자가 `USED-IDS` 중에서 고유한지 테스트합니다. 조건은 다음과 같습니다:

-   If `DATE` is non-nil, invoke `denote-prompt-for-date-return-id`.

    `DATE` 가 0 이 아닌 경우 `denote-prompt-for-date-return-id` 을 호출합니다.
-   If `DATE` is nil, use the file attributes to determine the last modified date and format it as an identifier.

    `DATE` 가 nil 인 경우 파일 속성을 사용하여 마지막으로 수정한 날짜를 확인하고 식별자로 형식을 지정합니다.
-   As a fallback, derive an identifier from the current time.

    대체 수단으로 현재 시간에서 식별자를 도출합니다.

With optional `USED-IDS` as nil, test that the identifier is unique among all files and buffers in variable `denote-directory`.

선택 사항인 `USED-IDS` 을 nil 로 설정하고 변수 `denote-directory` 의 모든 파일과 버퍼에서 식별자가 고유한지 테스트합니다.

To only return an existing identifier, refer to the function `denote-retrieve-filename-identifier`.

기존 식별자만 반환하려면 `denote-retrieve-filename-identifier` 함수를 참조하세요.

Function denote-retrieve-filename-title기능 denote-retrieve-filename-title :: Extract title from FILE name, else return file-name-base. Run denote-desluggify on the title if the extraction is successful.

`FILE` 이름에서 제목을 추출하고, 그렇지 않으면 `file-name-base` 을 반환합니다. 추출에 성공하면 제목에서 `denote-desluggify` 을 실행합니다.

Function denote-retrieve-title-value기능 denote-retrieve-title-value :: Return title value from FILE front matter per FILE-TYPE.

`FILE-TYPE` 에 따라 `FILE` 의 제목 값을 반환합니다.

Function denote-retrieve-title-line기능 denote-retrieve-title-line :: Return title line from FILE front matter per FILE-TYPE.

`FILE-TYPE` 에 따라 `FILE` 에서 제목 줄을 반환합니다.

Function denote-retrieve-keywords-value기능 denote-retrieve-keywords-value :: Return keywords value from FILE front matter per FILE-TYPE. The return value is a list of strings. To get a combined string the way it would appear in a Denote file name, use denote-retrieve-keywords-value-as-string [ That function is part of 2.1.0-dev. ].

`FILE-TYPE` 에 따라 `FILE` 에서 키워드 값을 반환합니다. 반환 값은 문자열 목록입니다. Denote 파일 이름에 표시되는 방식으로 결합된 문자열을 얻으려면 `denote-retrieve-keywords-value-as-string` [ 이 함수는 2.1.0-dev 에 포함되어 있습니다.]

Function denote-retrieve-keywords-value-as-string기능 denote-retrieve-keywords-value-as-string :: Return keywords value from FILE front matter per FILE-TYPE. The return value is a string, with the underscrore as a separator between individual keywords. To get a list of strings instead, use denote-retrieve-keywords-value (the current function uses that internally). [ Part of 2.1.0-dev. ]

`FILE-TYPE` 에 따라 `FILE` 에서 키워드 값을 반환합니다. 반환 값은 문자열이며, 밑줄은 개별 키워드 사이의 구분 기호로 사용됩니다. 대신 문자열 목록을 가져오려면 `denote-retrieve-keywords-value` (현재 함수는 내부적으로 이를 사용합니다)를 사용합니다. [ 2.1.0 개발 버전에 포함됨 ]의 일부입니다.

Function denote-retrieve-keywords-line기능 denote-retrieve-keywords-line :: Return keywords line from FILE front matter per FILE-TYPE.

`FILE-TYPE` 에 따라 `FILE` 에서 키워드 줄을 반환합니다.

Function denote-signature-prompt기능 denote-signature-prompt :: Prompt for signature string. With optional DEFAULT-SIGNATURE use it as the default minibuffer value. With optional PROMPT-TEXT use it in the minibuffer instead of the default prompt. Previous inputs at this prompt are available for minibuffer completion. Consider savehist-mode to persist minibuffer histories between sessions. [ The DEFAULT-SIGNATURE and PROMPT-TEXT arguments, as well as previous input completion, are added as part of 2.1.0-dev. ]

서명 문자열을 입력하라는 메시지를 표시합니다. `DEFAULT-SIGNATURE` 옵션을 사용하면 기본 미니버퍼 값으로 사용합니다. `PROMPT-TEXT` 옵션을 사용하면 기본 프롬프트 대신 미니버퍼에 사용합니다. 이 프롬프트에서 이전 입력을 미니버퍼 완료에 사용할 수 있습니다. 세션 간에 미니버퍼 기록을 유지하려면 `savehist-mode` 를 고려하세요. [ `DEFAULT-SIGNATURE` 및 `PROMPT-TEXT` 인수와 이전 입력 완료는 2.1.0-dev 에 추가되었습니다. ]

Function denote-file-prompt기능 denote-file-prompt : Prompt for file with identifier in variable denote-directory. With optional FILES-MATCHING-REGEXP, filter the candidates per the given regular expression. [ Refactored as part of 2.1.0-dev because the old INITIAL-INPUT argument was not actually used anywhere. ]

변수에 식별자가 있는 파일을 입력하라는 메시지가 표시됩니다 `denote-directory` . 선택 사항으로 `FILES-MATCHING-REGEXP` 를 사용하면 주어진 정규식에 따라 후보를 필터링합니다. [이전 `INITIAL-INPUT` 인수가 실제로 어디에서도 사용되지 않았기 때문에 2.1.0-dev 의 일부로 리팩터링되었습니다. ]

Function denote-keywords-prompt기능 denote-keywords-prompt :: Prompt for one or more keywords. Read entries as separate when they are demarcated by the crm-separator, which typically is a comma. With optional PROMPT-TEXT, use it to prompt the user for keywords. Else use a generic prompt. Process the return value with denote-keywords-sort and sort with string-collate-lessp if the user option denote-sort-keywords is non-nil. [ Refactored as part of 2.1.0-dev to refine how the sorting is done and to include the optional PROMPT-TEXT. ]

하나 이상의 키워드를 입력하라는 메시지가 표시됩니다. 일반적으로 쉼표인 `crm-separator` 로 구분된 항목은 별도의 항목으로 읽습니다. 선택 사항으로 `PROMPT-TEXT` 를 사용하여 사용자에게 키워드를 입력하라는 메시지를 표시합니다. 그렇지 않으면 일반 프롬프트를 사용합니다. 사용자 옵션 `denote-sort-keywords` 이 nil 이 아닌 경우 `denote-keywords-sort` 으로 반환 값을 처리하고 `string-collate-lessp` 으로 정렬합니다. [ 2.1.0-dev 의 일부로 리팩터링되어 정렬이 수행되는 방식을 개선하고 `PROMPT-TEXT` 옵션을 포함하도록 개선되었습니다. ]

Function denote-title-prompt기능 denote-title-prompt : Read file title for denote. With optional DEFAULT-TITLE use it as the default value. With optional PROMPT-TEXT use it in the minibuffer instead of the generic prompt. Previous inputs at this prompt are available for minibuffer completion. Consider savehist-mode to persist minibuffer histories between sessions. [ The PROMPT-TEXT and completion of previous inputs are part of 2.1.0-dev. ]

`denote` 에 대한 파일 제목을 읽습니다. 선택 사항으로 `DEFAULT-TITLE` 을 기본값으로 사용합니다. `PROMPT-TEXT` 옵션을 사용하면 일반 프롬프트 대신 미니버퍼에서 사용합니다. 이 프롬프트에서 이전 입력을 미니버퍼 완료에 사용할 수 있습니다. 세션 간에 미니버퍼 기록을 유지하려면 `savehist-mode` 를 고려하세요. [ `PROMPT-TEXT` 및 이전 입력 완료는 2.1.0-dev 의 일부입니다.]

Variable denote-title-prompt-current-default변수 denote-title-prompt-current-default :: Currently bound default title for denote-title-prompt. Set the value of this variable within the lexical scope of a command that needs to supply a default title before calling denote-title-prompt and use unwind-protect to set its value back to nil. [ Part of 2.1.0-dev. ]

현재 바인딩된 기본 제목은 `denote-title-prompt` 입니다. `denote-title-prompt` 을 호출하기 전에 기본 제목을 제공해야 하는 명령의 어휘 범위 내에서 이 변수의 값을 설정하고 `unwind-protect` 을 사용하여 값을 다시 nil 로 설정합니다. [ 2.1.0 개발 버전에 포함됨 ].

Function denote-file-type-prompt기능 denote-file-type-prompt :: Prompt for denote-file-type. Note that a non-nil value other than text, markdown-yaml, and markdown-toml falls back to an Org file type. We use org here for clarity.

`denote-file-type` 를 입력하라는 메시지가 표시됩니다. `text` , `markdown-yaml` , `markdown-toml` 이 아닌 값은 Org 파일 유형으로 되돌아갑니다. 여기서는 명확성을 위해 `org` 를 사용합니다.

Function denote-date-prompt기능 denote-date-prompt : Prompt for date, expecting YYYY-MM-DD or that plus HH:MM (or even HH:MM:SS). Use Org's more advanced date selection utility if the user option denote-date-prompt-use-org-read-date is non-nil. It requires Org ().

`YYYY-MM-DD` 또는 여기에 `HH:MM` (또는 `HH:MM:SS` )을 더한 날짜를 입력하라는 메시지가 표시됩니다. 사용자 옵션 `denote-date-prompt-use-org-read-date` 이 0 이 아닌 경우 Org 의 고급 날짜 선택 유틸리티를 사용합니다. 이 유틸리티를 사용하려면 Org(날짜 표시 프롬프트 사용-오르그 읽기 날짜 옵션)가 필요합니다.

Function denote-command-prompt기능 denote-command-prompt :: Prompt for command among denote-commands-for-new-notes (). [ Part of 2.1.0-dev. ]

`denote-commands-for-new-notes` (입력 지점) 중 명령 프롬프트. [ 2.1.0 개발 중 일부 ]입니다.

Function denote-prompt-for-date-return-id기능 denote-prompt-for-date-return-id :: Use denote-date-prompt and return it as denote-id-format.

`denote-date-prompt` 을 사용하여 `denote-id-format` 으로 반환합니다.

Function denote-template-prompt기능 denote-template-prompt :: Prompt for template key in denote-templates and return its value.

`denote-templates` 에 템플릿 키를 입력하라는 메시지를 표시하고 해당 값을 반환합니다.

Function denote-subdirectory-prompt기능 denote-subdirectory-prompt :: Prompt for subdirectory of the variable denote-directory. The table uses the file completion category (so it works with packages such as marginalia and embark).

변수의 하위 디렉터리를 입력하라는 프롬프트 `denote-directory` . 이 테이블은 `file` 완성 카테고리를 사용합니다(따라서 `marginalia` 및 `embark` 과 같은 패키지와 함께 작동합니다).

Function denote-rename-file-prompt기능 denote-rename-file-prompt :: Prompt to rename file named OLD-NAME to NEW-NAME.

`OLD-NAME` 이라는 파일 이름을 `NEW-NAME` 으로 변경하라는 메시지가 표시됩니다.

Function denote-rename-file-and-buffer기능 denote-rename-file-and-buffer :: Rename file named OLD-NAME to NEW-NAME, updating buffer name.

`OLD-NAME` 이라는 파일 이름을 `NEW-NAME` 으로 변경하여 버퍼 이름을 업데이트합니다.

Function denote-rewrite-front-matter기능 denote-rewrite-front-matter :: Rewrite front matter of note after denote-rename-file (or related) The FILE, TITLE, KEYWORDS, and FILE-TYPE arguments are given by the renaming command and are used to construct new front matter values if appropriate. With optional NO-CONFIRM, do not prompt to confirm the rewriting of the front matter. Otherwise produce a y-or-n-p prompt to that effect. [ The NO-CONFIRM argument is part of 2.1.0-dev. ]

`denote-rename-file` (또는 관련) 뒤에 머리글을 다시 작성 `FILE` , `TITLE` , `KEYWORDS` , `FILE-TYPE` 인수는 이름 바꾸기 명령에 의해 제공되며 적절한 경우 새 머리글 값을 구성하는 데 사용됩니다. 선택 사항으로 `NO-CONFIRM` 를 사용하면 머리글 재작성 확인 메시지를 표시하지 않습니다. 그렇지 않으면 `y-or-n-p` 프롬프트를 생성합니다. [ `NO-CONFIRM` 인수는 2.1.0-dev 의 일부입니다.]

Function denote-rewrite-keywords기능 denote-rewrite-keywords :: Rewrite KEYWORDS in FILE outright according to FILE-TYPE. Do the same as denote-rewrite-front-matter for keywords, but do not ask for confirmation. This is for use in denote-keywords-add, denote-keywords-remove, denote-dired-rename-marked-files-with-keywords, or related.

`FILE-TYPE` 에 따라 `KEYWORDS` 을 `FILE` 로 완전히 다시 작성합니다. 키워드의 경우 `denote-rewrite-front-matter` 와 동일하게 작성하되 확인을 요청하지 않습니다. `denote-keywords-add` , `denote-keywords-remove` , `denote-dired-rename-marked-files-with-keywords` 또는 관련 항목에서 사용하기 위한 것입니다.

Function denote-update-dired-buffers기능 denote-update-dired-buffers :: Update Dired buffers of variable denote-directory. Note that the denote-directory accepts a directory-local value for what we internally refer to as “silos” ().

`denote-directory` 변수의 Dired 버퍼를 업데이트합니다. `denote-directory` 은 내부적으로 "사일로"라고 부르는 디렉터리 로컬 값을 허용합니다(노트에 대해 별도의 디렉터리를 유지하세요).

Variable denote-file-types변수 denote-file-types : Alist of denote-file-type and their format properties.

`denote-file-type` 및 해당 형식 속성 목록입니다.

Each element is of the form `(SYMBOL PROPERTY-LIST)`. `SYMBOL` is one of those specified in `denote-file-type` or an arbitrary symbol that defines a new file type.

각 요소의 형식은 `(SYMBOL PROPERTY-LIST)` 입니다. `SYMBOL` 은 `denote-file-type` 에 지정된 것 중 하나이거나 새 파일 유형을 정의하는 임의의 기호입니다.

`PROPERTY-LIST` is a plist that consists of the following elements:

`PROPERTY-LIST` 는 다음 요소로 구성된 목록입니다:

1.  `:extension` is a string with the file extension including the period.

    `:extension` 는 마침표를 포함한 파일 확장명을 가진 문자열입니다.
2.  `:date-function` is a function that can format a date. See the functions `denote--date-iso-8601`, `denote--date-rfc3339`, and `denote--date-org-timestamp`.

    `:date-function` 는 날짜 서식을 지정할 수 있는 함수입니다. `denote--date-iso-8601` , `denote--date-rfc3339` , `denote--date-org-timestamp` 함수를 참조하세요.
3.  `:front-matter` is either a string passed to `format` or a variable holding such a string. The `format` function accepts four arguments, which come from `denote` in this order: `TITLE`, `DATE`, `KEYWORDS`, `IDENTIFIER`. Read the doc string of `format` on how to reorder arguments.

    `:front-matter` 는 `format` 에 전달된 문자열이거나 해당 문자열이 저장된 변수입니다. `format` 함수는 `denote` 에서 다음 순서로 네 개의 인수를 받습니다: `TITLE` , `DATE` , `KEYWORDS` , `IDENTIFIER` 입니다. 인수의 순서를 변경하는 방법은 `format` 의 문서 문자열을 참조하세요.
4.  `:title-key-regexp` is a regular expression that is used to retrieve the title line in a file. The first line matching this regexp is considered the title line.

    `:title-key-regexp` 는 파일에서 제목 줄을 검색하는 데 사용되는 정규식입니다. 이 정규식과 일치하는 첫 번째 줄이 제목 줄로 간주됩니다.
5.  `:title-value-function` is the function used to format the raw title string for inclusion in the front matter (e.g. to surround it with quotes). Use the `identity` function if no further processing is required.

    `:title-value-function` 은 제목 문자열을 따옴표로 둘러싸는 등 앞부분에 포함하기 위해 원시 제목 문자열의 서식을 지정하는 데 사용되는 함수입니다. 추가 처리가 필요하지 않은 경우 `identity` 함수를 사용합니다.
6.  `:title-value-reverse-function` is the function used to retrieve the raw title string from the front matter. It performs the reverse of `:title-value-function`.

    `:title-value-reverse-function` 는 앞부분에서 원시 제목 문자열을 검색하는 데 사용되는 함수입니다. `:title-value-function` 의 역방향을 수행합니다.
7.  `:keywords-key-regexp` is a regular expression used to retrieve the keywords' line in the file. The first line matching this regexp is considered the keywords' line.

    `:keywords-key-regexp` 는 파일에서 키워드의 줄을 검색하는 데 사용되는 정규식입니다. 이 정규식과 일치하는 첫 번째 줄이 키워드의 줄로 간주됩니다.
8.  `:keywords-value-function` is the function used to format the keywords' list of strings as a single string, with appropriate delimiters, for inclusion in the front matter.

    `:keywords-value-function` 는 키워드의 문자열 목록을 적절한 구분 기호를 사용하여 앞부분에 포함할 수 있도록 단일 문자열로 포맷하는 데 사용되는 함수입니다.
9.  `:keywords-value-reverse-function` is the function used to retrieve the keywords' value from the front matter. It performs the reverse of the `:keywords-value-function`.

    `:keywords-value-reverse-function` 는 앞부분에서 키워드의 값을 검색하는 데 사용되는 함수입니다. `:keywords-value-function` 의 역방향을 수행합니다.
10. `:link` is a string, or variable holding a string, that specifies the format of a link. See the variables `denote-org-link-format`, `denote-md-link-format`.

    `:link` 는 링크의 형식을 지정하는 문자열 또는 문자열을 담고 있는 변수입니다. `denote-org-link-format` , `denote-md-link-format` 변수를 참조하세요.
11. `:link-in-context-regexp` is a regular expression that is used to match the aforementioned link format. See the variables `denote-org-link-in-context-regexp`, `denote-md-link-in-context-regexp`.

    `:link-in-context-regexp` 는 앞서 언급한 링크 형식과 일치하는 데 사용되는 정규식입니다. `denote-org-link-in-context-regexp` , `denote-md-link-in-context-regexp` 변수를 참조하세요.

If `denote-file-type` is nil, use the first element of this list for new note creation. The default is `org`.

`denote-file-type` 가 0 이면 이 목록의 첫 번째 요소를 사용해 새 노트를 만듭니다. 기본값은 `org` 입니다.

Variable denote-org-front-matter변수 denote-org-front-matter :: Specifies the Org front matter. It is passed to format with arguments TITLE, DATE, KEYWORDS, ID ()

조직 앞부분을 지정합니다. 인자 `TITLE` , `DATE` , `KEYWORDS` , `ID` (머리말 형식 변경)와 함께 `format` 로 전달됩니다.

Variable denote-yaml-front-matter변수 denote-yaml-front-matter :: Specifies the YAML (Markdown) front matter. It is passed to format with arguments TITLE, DATE, KEYWORDS, ID ()

YAML(마크다운) 앞부분을 지정합니다. 인자 `TITLE` , `DATE` , `KEYWORDS` , `ID` (머리말 형식 변경)와 함께 `format` 로 전달됩니다.

Variable denote-toml-front-matter변수 denote-toml-front-matter :: Specifies the TOML (Markdown) front matter. It is passed to format with arguments TITLE, DATE, KEYWORDS, ID ()

TOML(마크다운) 앞부분을 지정합니다. 인자 `TITLE` , `DATE` , `KEYWORDS` , `ID` (머리말 형식 변경)과 함께 `format` 로 전달됩니다.

Variable denote-text-front-matter변수 denote-text-front-matter :: Specifies the plain text front matter. It is passed to format with arguments TITLE, DATE, KEYWORDS, ID ()

일반 텍스트 앞부분을 지정합니다. 인자 `TITLE` , `DATE` , `KEYWORDS` , `ID` (머리말 형식 변경)와 함께 `format` 로 전달됩니다.

Variable denote-org-link-format변수 denote-org-link-format :: Format of Org link to note. The value is passed to format with IDENTIFIER and TITLE arguments, in this order. Also see denote-org-link-in-context-regexp.

참고할 조직 링크의 형식입니다. 값은 `IDENTIFIER` 및 `TITLE` 인수를 사용하여 `format` 에 전달됩니다(순서대로). `denote-org-link-in-context-regexp` 를 참조하세요.

Variable denote-md-link-format변수 denote-md-link-format :: Format of Markdown link to note. The %N$s notation used in the default value is for format as the supplied arguments are IDENTIFIER and TITLE, in this order. Also see denote-md-link-in-context-regexp.

메모할 마크다운 링크의 형식입니다. 기본값에 사용되는 `%N$s` 표기는 `format` 에 대한 것으로, 제공된 인수는 `IDENTIFIER` 및 `TITLE` 순서입니다. `denote-md-link-in-context-regexp` 를 참조하세요.

Variable denote-id-only-link-format변수 denote-id-only-link-format :: Format of identifier-only link to note. The value is passed to format with IDENTIFIER as its sole argument. Also see denote-id-only-link-in-context-regexp.

노트에 대한 식별자 전용 링크의 형식입니다. 값은 `IDENTIFIER` 을 유일한 인수로 하여 `format` 으로 전달됩니다. `denote-id-only-link-in-context-regexp` 를 참조하세요.

Variable denote-org-link-in-context-regexp변수 denote-org-link-in-context-regexp :: Regexp to match an Org link in its context. The format of such links is denote-org-link-format.

정규식을 사용하여 해당 컨텍스트에서 조직 링크와 일치하도록 합니다. 이러한 링크의 형식은 `denote-org-link-format` 입니다.

Variable denote-md-link-in-context-regexp변수 denote-md-link-in-context-regexp :: Regexp to match an Markdown link in its context. The format of such links is denote-md-link-format.

정규식을 사용하여 컨텍스트에서 마크다운 링크와 일치하도록 합니다. 이러한 링크의 형식은 `denote-md-link-format` 입니다.

Variable denote-id-only-link-in-context-regexp변수 denote-id-only-link-in-context-regexp :: Regexp to match an identifier-only link in its context. The format of such links is denote-id-only-link-format.

정규식을 사용하여 해당 컨텍스트에서 식별자 전용 링크와 일치시킵니다. 이러한 링크의 형식은 `denote-id-only-link-format` 입니다.

Function denote-surround-with-quotes기능 denote-surround-with-quotes :: Surround string S with quotes. This can be used in denote-file-types to format front mattter.

따옴표로 묶는 문자열 `S` . `denote-file-types` 에서 앞쪽 자료의 서식을 지정하는 데 사용할 수 있습니다.

Function denote-date-org-timestamp기능 denote-date-org-timestamp :: Format DATE using the Org inactive timestamp notation.

조직 비활성 타임스탬프 표기법을 사용하여 `DATE` 형식을 지정합니다.

Function denote-date-rfc3339기능 denote-date-rfc3339 : Format DATE using the RFC3339 specification.

RFC3339 사양을 사용하여 `DATE` 형식을 지정합니다.

Function denote-date-iso-8601기능 denote-date-iso-8601 : Format DATE according to ISO 8601 standard.

ISO 8601 표준에 따라 `DATE` 형식을 지정합니다.

Function denote-trim-whitespace기능 denote-trim-whitespace :: Trim whitespace around string S. This can be used in denote-file-types to format front mattter.

문자열 주위의 공백을 다듬습니다 `S` . `denote-file-types` 에서 앞쪽 자료의 서식을 지정하는 데 사용할 수 있습니다.

Function denote-trim-whitespace-then-quotes기능 denote-trim-whitespace-then-quotes :: Trim whitespace then quotes around string S. This can be used in denote-file-types to format front mattter.

공백을 다듬은 다음 문자열 `S` 주위에 따옴표를 붙입니다. `denote-file-types` 에서 앞머리의 서식을 지정하는 데 사용할 수 있습니다.

Function denote-format-keywords-for-md-front-matter기능 denote-format-keywords-for-md-front-matter :: Format front matter KEYWORDS for markdown file type. KEYWORDS is a list of strings. Consult the denote-file-types for how this is used.

마크다운 파일 형식은 앞부분 `KEYWORDS` 형식입니다. `KEYWORDS` 은 문자열 목록입니다. 사용 방법은 `denote-file-types` 을 참조하세요.

Function denote-format-keywords-for-text-front-matter기능 denote-format-keywords-for-text-front-matter :: Format front matter KEYWORDS for text file type. KEYWORDS is a list of strings. Consult the denote-file-types for how this is used.

텍스트 파일 형식의 경우 앞부분은 `KEYWORDS` , `KEYWORDS` 은 문자열 목록입니다. 사용 방법은 `denote-file-types` 을 참조하세요.

Function denote-format-keywords-for-org-front-matter기능 denote-format-keywords-for-org-front-matter :: Format front matter KEYWORDS for org file type. KEYWORDS is a list of strings. Consult the denote-file-types for how this is used.

조직 파일 형식의 경우 앞부분 `KEYWORDS` 형식입니다. `KEYWORDS` 은 문자열 목록입니다. 사용 방법은 `denote-file-types` 을 참조하세요.

Function denote-extract-keywords-from-front-matter기능 denote-extract-keywords-from-front-matter :: Format front matter KEYWORDS for org file type. KEYWORDS is a list of strings. Consult the denote-file-types for how this is used.

조직 파일 형식의 경우 앞부분 `KEYWORDS` 형식입니다. `KEYWORDS` 은 문자열 목록입니다. 사용 방법은 `denote-file-types` 을 참조하세요.

Function denote-link-return-links기능 denote-link-return-links :: Return list of links in current or optional FILE. Also see denote-link-return-backlinks.

현재 또는 선택 사항의 링크 목록 반환 `FILE` . `denote-link-return-backlinks` 도 참조하세요.

Function denote-link-return-backlinks기능 denote-link-return-backlinks :: Return list of backlinks in current or optional FILE. Also see denote-link-return-links.

현재 또는 선택 사항으로 백링크 목록을 반환합니다 `FILE` . `denote-link-return-links` 도 참조하세요.

17. Troubleshoot Denote in a pristine environment

1. 깨끗한 환경에서 Denote 문제 해결

Sometimes we get reports on bugs that may not be actually caused by some error in the Denote code base. To help gain insight into what the problem is, we need to be able to reproduce the issue in a minimum viable system. Below is one way to achieve this.

때때로 Denote 코드 베이스의 오류로 인한 것이 아닐 수도 있는 버그에 대한 보고를 받기도 합니다. 문제가 무엇인지에 대한 인사이트를 얻으려면 최소한의 실행 가능한 시스템에서 문제를 재현할 수 있어야 합니다. 아래는 이를 달성하는 한 가지 방법입니다.

1. Find where your denote.el file is stored on your filesystem.

   파일 시스템에서 denote.el 파일이 저장된 위치를 찾습니다.

2. Assuming you have already installed the package, one way to do this is to invoke M-x find-library and search for denote. It will take you to the source file. There do M-x eval-expression, which will bring up a minibuffer prompt. At the prompt evaluate:

   이미 패키지를 설치했다고 가정하면 M-x find-library 을 호출하고 denote 을 검색하는 것도 한 가지 방법입니다. 그러면 소스 파일로 이동합니다. M-x eval-expression 을 실행하면 미니버퍼 프롬프트가 나타납니다. 프롬프트에서 평가합니다:

(kill-new (expand-file-name (buffer-file-name)))

1. The above will save the full file system path to your kill ring.

   위와 같이 하면 킬링의 전체 파일 시스템 경로가 저장됩니다.

2. In a terminal emulator or an M-x shell buffer execute:

   터미널 에뮬레이터 또는 M-x shell 버퍼에서 실행합니다:

emacs -Q

1. This will open a new instance of Emacs in a pristine environment. Only the default settings are loaded.

   이렇게 하면 깨끗한 환경에서 Emac 의 새 인스턴스가 열립니다. 기본 설정만 로드됩니다.

2. In the *scratch* buffer of emacs -Q, add your configurations like the following and try to reproduce the issue:

   emacs -Q 의 *scratch* 버퍼에 다음과 같이 구성을 추가하고 문제를 재현해 보세요:

(require 'denote "/full/path/to/what/you/got/denote.el")
 
;; Your configurations here

Then try to see if your problem still occurs. If it does, then the fault is with Denote. Otherwise there is something external to it that we need to account for. Whatever the case, this exercise helps us get a better sense of the specifics.

그런 다음 문제가 여전히 발생하는지 확인해 보세요. 문제가 발생하면 Denote 에 결함이 있는 것입니다. 그렇지 않다면 고려해야 할 외부 요인이 있는 것입니다. 어떤 경우이든 이 연습을 통해 구체적인 사항을 더 잘 파악할 수 있습니다.

18. Contributing

Denote is a GNU ELPA package. As such, any significant change to the code requires copyright assignment to the Free Software Foundation (more below).

Denote 는 GNU ELPA 패키지입니다. 따라서 코드를 크게 변경하려면 자유 소프트웨어 재단에 저작권을 양도해야 합니다(자세한 내용은 아래 참조).

You do not need to be a programmer to contribute to this package. Sharing an idea or describing a workflow is equally helpful, as it teaches us something we may not know and might be able to cover either by extending Denote or expanding this manual (). If you prefer to write a blog post, make sure you share it with us: we can add a section herein referencing all such articles. Everyone gets acknowledged (). There is no such thing as an “insignificant contribution”---they all matter.

프로그래머가 아니어도 이 패키지에 기여할 수 있습니다. 아이디어를 공유하거나 워크플로우를 설명하는 것도 똑같이 도움이 되는데, 이는 저희가 모르는 것을 알려주어 Denote 를 확장하거나 이 매뉴얼('해야 할 일')을 확장하여 다룰 수 있기 때문입니다. 블로그 포스팅을 작성하고 싶으시다면 저희와 공유해 주세요. 여기에 그러한 모든 글을 참조하는 섹션을 추가할 수 있습니다. 모든 사람이 인정받기( 인정). '중요하지 않은 기여'란 없으며 모든 기여가 중요합니다.

• Package name (GNU ELPA): denote

  패키지 이름(GNU ELPA): denote

• Official manual: https://protesilaos.com/emacs/denote

  공식 매뉴얼: https://protesilaos.com/emacs/denote

• Change log: https://protesilaos.com/emacs/denote-changelog

  변경 로그: https://protesilaos.com/emacs/denote-changelog

• Git repo on SourceHut: https://git.sr.ht/~protesilaos/denote

  SourceHut 의 Git 리포지토리: https://git.sr.ht/~protesilaos/denote

  • Mirrors: 거울:
    • GitHub: https://github.com/protesilaos/denote
    • GitLab: https://gitlab.com/protesilaos/denote

• Mailing list: https://lists.sr.ht/~protesilaos/denote

  메일링 리스트: https://lists.sr.ht/~protesilaos/denote

If our public media are not suitable, you are welcome to contact me (Protesilaos) in private: https://protesilaos.com/contact.

트위터의 공개 매체가 적합하지 않은 경우, 저(Protesilaos)에게 비공개로 문의하실 수 있습니다(https://protesilaos.com/contact).

Copyright assignment is a prerequisite to sharing code. It is a simple process. Check the request form below (please adapt it accordingly). You must write an email to the address mentioned in the form and then wait for the FSF to send you a legal agreement. Sign the document and file it back to them. This could all happen via email and take about a week. You are encouraged to go through this process. You only need to do it once. It will allow you to make contributions to Emacs in general.

저작권 할당은 코드 공유의 전제 조건입니다. 절차는 간단합니다. 아래 요청 양식을 확인하세요(필요에 따라 수정하세요). 양식에 기재된 주소로 이메일을 보낸 다음 FSF 에서 법적 계약서를 보내줄 때까지 기다려야 합니다. 문서에 서명하고 다시 제출하세요. 이 모든 과정은 이메일을 통해 이루어지며 약 1 주일 정도 소요됩니다. 이 과정을 거치는 것이 좋습니다. 한 번만 하면 됩니다. 이를 통해 일반적으로 Emacs 에 기여할 수 있습니다.

Please email the following information to assign@gnu.org, and we
will send you the assignment form for your past and future changes.
 
Please use your full legal name (in ASCII characters) as the subject
line of the message.
 
REQUEST: SEND FORM FOR PAST AND FUTURE CHANGES
 
[What is the name of the program or package you're contributing to?]
 
GNU Emacs
 
[Did you copy any files or text written by someone else in these changes?
Even if that material is free software, we need to know about it.]
 
Copied a few snippets from the same files I edited.  Their author,
Protesilaos Stavrou, has already assigned copyright to the Free Software
Foundation.
 
[Do you have an employer who might have a basis to claim to own
your changes?  Do you attend a school which might make such a claim?]
 
 
[For the copyright registration, what country are you a citizen of?]
 
 
[What year were you born?]
 
 
[Please write your email address here.]
 
 
[Please write your postal address here.]
 
 
 
 
 
[Which files have you changed so far, and which new files have you written
so far?]

19. Things to do

할 일

Denote should work well for what is described in this manual. Though we can always do better. This is a non-exhaustive list with some low-priority ideas you may want to help with ().

이 매뉴얼에 설명된 내용에 대해 잘 작동해야 합니다. 하지만 언제나 더 잘할 수 있습니다. 이 목록은 여러분이 도움을 줄 수 있는 우선순위가 낮은 몇 가지 아이디어(기여)가 포함된 전체 목록이 아닙니다.

• Support mutually-exclusive sets of tags. For example, a home keyword would preclude work. Personally, I am not a fan of such arrangements as there may be a case where something applies to both ends of this prefigured binary. Though we can think about it.

  상호 배타적인 태그 집합을 지원합니다. 예를 들어 home 키워드는 work 을 제외합니다. 개인적으로 저는 이 사전 설정된 이진법의 양쪽 끝에 모두 적용되는 경우가 있을 수 있기 때문에 이러한 배열을 좋아하지 않습니다. 하지만 생각해 볼 수는 있습니다.

• Add command that expands the identifier in links to a full file name. This would be useful for some sort of “export” operation where the absolute file path is necessary and where the Denote linking mechanism is not available. Though this could be handled by the exporter, by doing something like what denote-find-link does.

  추가 명령은 링크의 식별자를 전체 파일 이름으로 확장합니다. 이 명령은 절대 파일 경로가 필요하고 Denote 연결 메커니즘을 사용할 수 없는 일종의 "내보내기" 작업에 유용합니다. 이 작업은 내보내기가 처리할 수도 있지만 denote-find-link 과 같은 작업을 수행하면 됩니다.

• Add command that rewrites full names in links, if they are invalid. This would complement the renaming mechanism. Personally, I think old titles in links are not a problem, because they show you what was true at the time and are usually relevant to their context. Again though, it is an option worth exploring.

  링크의 전체 이름이 유효하지 않은 경우 다시 작성하는 명령을 추가합니다. 이렇게 하면 이름 바꾸기 메커니즘을 보완할 수 있습니다. 개인적으로 링크의 오래된 제목은 당시의 사실을 보여주고 일반적으로 문맥과 관련이 있기 때문에 문제가 되지 않는다고 생각합니다. 하지만 다시 한 번 살펴볼 가치가 있는 옵션입니다.

• Ensure integration between denote: links and the embark package. The idea is to allow Embark to understand the Denote buttons are links to files and correctly infer the absolute path. I am not sure what a user would want to do with this, but maybe there are some interesting possibilities.

  denote: 링크와 embark 패키지 간의 통합을 확인합니다. 이 아이디어는 Embark 가 표시 버튼이 파일에 대한 링크라는 것을 이해하고 절대 경로를 올바르게 추론할 수 있도록 하는 것입니다. 사용자가 이 기능으로 무엇을 하고 싶어할지는 모르겠지만 몇 가지 흥미로운 가능성이 있을 수 있습니다.

You are welcome to suggest more ideas. If they do not broaden the scope of Denote, they can be added to denote.el. Otherwise we might think of extensions to the core package.

더 많은 아이디어를 제안하실 수 있습니다. Denote 의 범위를 넓히지 않는다면 denote.el 에 추가할 수 있습니다. 그렇지 않으면 코어 패키지에 대한 확장을 고려할 수도 있습니다.

20. Publications about Denote

Denote 에 대한 간행물

The Emacs community is putting Denote to great use. This section includes publications that show how people configure their note-taking setup. If you have a blog post, video, or configuration file about Denote, feel welcome to tell us about it ().

Emacs 커뮤니티는 Denote 를 훌륭하게 활용하고 있습니다. 이 섹션에는 사람들이 노트 필기 설정을 구성하는 방법을 보여주는 게시물이 포함되어 있습니다. Denote 에 관한 블로그 게시물, 동영상, 구성 파일이 있으시다면 언제든지 저희에게 알려주세요( 기여하기).

• David Wilson (SystemCrafters): Generating a Blog Site from Denote Entries, 2022-09-09, https://www.youtube.com/watch?v=5R7ad5xz5wo

  데이비드 윌슨(시스템 크래프터스): Denote 항목에서 블로그 사이트 생성하기, 2022-09-09, https://www.youtube.com/watch?v=5R7ad5xz5wo

• David Wilson (SystemCrafters): Trying Out Prot's Denote, an Org Roam Alternative?, 2022-07-15, https://www.youtube.com/watch?v=QcRY_rsX0yY

  데이비드 윌슨(시스템 크래프터스): 조직 로밍 대안인 Prot's Denote 를 사용해 보시겠습니까?, 2022-07-15, https://www.youtube.com/watch?v=QcRY_rsX0yY

• Jack Baty: Keeping my Org Agenda updated based on Denote keywords, 2022-11-30, https://baty.net/2022/keeping-my-org-agenda-updated

  잭 바티: Denote 키워드를 기반으로 내 조직 안건 업데이트하기, 2022-11-30, https://baty.net/2022/keeping-my-org-agenda-updated

• Jeremy Friesen: Denote Emacs Configuration, 2022-10-02, https://takeonrules.com/2022/10/09/denote-emacs-configuration/

  제레미 프라이슨: 이맥스 구성 표시, 2022-10-02, https://takeonrules.com/2022/10/09/denote-emacs-configuration/

• Jeremy Friesen: Exploring the Denote Emacs Package, 2022-10-01, https://takeonrules.com/2022/10/01/exploring-the-denote-emacs-package/

  제레미 프라이슨: Denote Emacs 패키지 살펴보기, 2022-10-01, https://takeonrules.com/2022/10/01/exploring-the-denote-emacs-package/

• Jeremy Friesen: Migration Plan for Org-Roam Notes to Denote, 2022-10-02, https://takeonrules.com/2022/10/02/migration-plan-for-org-roam-notes-to-denote/

  제레미 프라이슨: Org-Roam 메모를 나타내는 마이그레이션 계획, 2022-10-02, https://takeonrules.com/2022/10/02/migration-plan-for-org-roam-notes-to-denote/

• Jeremy Friesen: Project Dispatch Menu with Org Mode Metadata, Denote, and Transient, 2022-11-19, https://takeonrules.com/2022/11/19/project-dispatch-menu-with-org-mode-metadata-denote-and-transient/

  제레미 프라이슨: 조직 모드 메타데이터, 표시 및 트랜지언트가 포함된 프로젝트 디스패치 메뉴, 2022-11-19, https://takeonrules.com/2022/11/19/project-dispatch-menu-with-org-mode-metadata-denote-and-transient/

• Mohamed Suliman: Managing a bibliography of BiBTeX entries with Denote, 2022-12-20, https://www.scss.tcd.ie/~sulimanm/posts/denote-bibliography.html

  모하메드 술리만: Denote 로 BiBTeX 출품작의 참고 문헌 관리하기, 2022-12-20, https://www.scss.tcd.ie/~sulimanm/posts/denote-bibliography.html

• Peter Prevos: Simulating Text Files with R to Test the Emacs Denote Package, 2022-07-28, https://lucidmanager.org/productivity/testing-denote-package/

  피터 프레보스: R 로 텍스트 파일 시뮬레이션하여 Emacs Denote 패키지 테스트하기, 2022-07-28, https://lucidmanager.org/productivity/testing-denote-package/

• Peter Prevos: Emacs Writing Studio, 2023-10-19. A configuration for authors, using Denote for taking notes, literature reviews and manage collections of images:

  피터 프레보스: 이맥스 라이팅 스튜디오, 2023-10-19. Denote 를 사용해 노트 필기, 문헌 검토, 이미지 컬렉션 관리를 하는 저자를 위한 구성입니다:

  • https://lucidmanager.org/productivity/taking-notes-with-emacs-denote/
  • https://lucidmanager.org/productivity/bibliographic-notes-in-emacs-with-citar-denote/
  • https://lucidmanager.org/productivity/using-emacs-image-dired/

• Stefan Thesing: Denote as a Zettelkasten, 2023-03-02, https://www.thesing-online.de/blog/denote-as-a-zettelkasten

  스테판 테싱: 제텔카스텐으로 표시, 2023-03-02, https://www.thesing-online.de/blog/denote-as-a-zettelkasten

• Summer Emacs: An explanation of how I use Emacs, 2023-05-04, https://github.com/summeremacs/howiuseemacs/blob/main/full-explanation-of-how-i-use-emacs.org

  여름 이맥스: 이맥스를 사용하는 방법에 대한 설명, 2023-05-04, https://github.com/summeremacs/howiuseemacs/blob/main/full-explanation-of-how-i-use-emacs.org

21. Alternatives to Denote

What follows is a list of Emacs packages for note-taking. I (Protesilaos) have not used any of them, as I was manually applying my file-naming scheme beforehand and by the time those packages were available I was already hacking on the predecessor of Denote as a means of learning Emacs Lisp (a package which I called “Unassuming Sidenotes of Little Significance”, aka “USLS” which is pronounced as “U-S-L-S” or “useless”). As such, I cannot comment at length on the differences between Denote and each of those packages, beside what I gather from their documentation.

다음은 노트 필기를 위한 Emacs 패키지 목록입니다. 저는 이 중 어떤 것도 사용해 본 적이 없는데, 그 전에는 파일 명명 체계를 수동으로 적용하고 있었고, 이 패키지들이 출시될 무렵에는 이미 Emacs Lisp 를 배우기 위한 수단으로 Denote 의 전신인 "별 의미 없는 사이드노트"("U-S-L-S" 또는 "쓸모없는"으로 발음되는 "USLS"라고도 하는 패키지)를 해킹하고 있었기 때문입니다. 따라서 문서에서 얻은 정보 외에는 Denote 와 각 패키지의 차이점에 대해 자세히 언급할 수 없습니다.

org-roam 조직 로밍 : The de facto standard in the Emacs milieu---and rightly so! It has a massive community, is featureful, and should be an excellent companion to anyone who is invested in the Org ecosystem and/or knows what “Roam” is (I don't). It has been explained to me that Org Roam uses a database to store a cache about your notes. It otherwise uses standard Org files. The cache helps refer to the same node through aliases which can provide lots of options. Personally, I follow a single-topic-per-note approach, so anything beyond that is overkill. If the database is only for a cache, then maybe that has no downside, though I am careful with any kind of specialised program as it creates a dependency. If you ask me about database software in particular, I have no idea how to use one, let alone debug it or retrieve data from it if something goes awry (I could learn, but that is beside the point).

Emacs 환경의 사실상 표준이며, 당연히 그렇습니다! 방대한 커뮤니티가 있고, 기능이 풍부하며, Org 생태계에 투자했거나 "로밍"이 무엇인지 아는 사람이라면 누구에게나 훌륭한 동반자가 될 것입니다(저는 모릅니다). Org Roam 은 데이터베이스를 사용해 노트에 대한 캐시를 저장한다고 설명해 드린 적이 있습니다. 그 외에는 표준 Org 파일을 사용합니다. 캐시는 별칭을 통해 동일한 노드를 참조할 수 있도록 도와주어 다양한 옵션을 제공할 수 있습니다. 개인적으로 저는 노트당 단일 주제 접근 방식을 따르기 때문에, 그 이상의 것은 과잉이라고 생각합니다. 데이터베이스가 캐시 용도로만 사용된다면 단점이 없을 수도 있지만, 어떤 종류의 특수 프로그램도 종속성을 유발하기 때문에 조심스럽습니다. 특히 데이터베이스 소프트웨어에 대해 물어본다면, 문제가 발생했을 때 디버깅이나 데이터 검색은커녕 사용 방법도 전혀 모릅니다(배울 수는 있지만 요점을 벗어난 이야기입니다).

zk (or zk.el) zk(또는 zk.el) : Reading its documentation makes me think that this is Denote's sibling---the two projects have a lot of things in common, including the preference to rely on plain files and standard tools. The core difference is that Denote has a strict file-naming scheme. Other differences in available features are, in principle, matters of style or circumstance: both packages can have them. As its initials imply, ZK enables a zettelkasten-like workflow. It does not enforce it though, letting the user adapt the method to their needs and requirements.

문서를 읽다 보니 이 프로젝트가 Denote 의 형제라는 생각이 들었습니다. 두 프로젝트는 일반 파일과 표준 도구를 선호한다는 점 등 많은 공통점을 가지고 있습니다. 가장 큰 차이점은 Denote 는 파일 이름 지정 체계가 엄격하다는 점입니다. 사용 가능한 기능의 다른 차이점은 원칙적으로 스타일이나 상황의 문제이며, 두 패키지 모두 해당 기능을 사용할 수 있습니다. 이니셜에서 알 수 있듯이 ZK 는 제텔카스텐과 유사한 워크플로우를 지원합니다. 하지만 이를 강제하지는 않으므로 사용자가 자신의 필요와 요구 사항에 맞게 방법을 조정할 수 있습니다.

zettelkasten Zettel : This is another one of Denote's relatives, at least insofar as the goal of simplicity is concerned. The major difference is that according to its documentation “the name of the file that is created is just a unique ID”. This is not consistent with our file-naming scheme which is all about making sense of your files by their name alone and being able to visually parse a listing of them without any kind of specialised tool (e.g. ls -l or ls -C on the command-line from inside the denote-directory give you a human-readable set of files names, while find * -maxdepth 0 -type f is another approach).

이것은 적어도 단순성이라는 목표에 관한 한 Denote 의 또 다른 친척 중 하나입니다. 가장 큰 차이점은 문서에 따르면 "생성되는 파일의 이름은 단지 고유 ID 일 뿐"이라는 점입니다. 이는 파일 이름만으로 파일을 이해하고 특별한 도구 없이도 파일 목록을 시각적으로 구문 분석할 수 있도록 하는 저희의 파일 이름 지정 방식과 일치하지 않습니다(예: `denote-directory` 내부에서 명령줄에 `ls -l` 또는 `ls -C` 을 입력하면 사람이 읽을 수 있는 파일 이름 집합을 제공하고 `find * -maxdepth 0 -type f` 은 또 다른 접근 방식입니다).

zetteldeft setdeft : This is a zettelkasten note-taking system built on top of the deft package. Deft provides a search interface to a directory, in this case the one holding the user's zetteldeft notes. Denote has no such dependency and is not opinionated about how the user prefers to search/access their notes: use Dired, Grep, the consult package, or whatever else you already have set up for all things Emacs, not just your notes.

이것은 `deft` 패키지를 기반으로 구축된 제텔카스텐 노트 필기 시스템입니다. Deft 는 디렉터리(이 경우 사용자의 `zetteldeft` 노트가 있는 디렉터리)에 대한 검색 인터페이스를 제공합니다. Denote 는 이러한 종속성이 없으며 사용자가 선호하는 노트 검색/액세스 방식에 구애받지 않습니다: Dired, Grep, `consult` 패키지, 또는 노트뿐 아니라 이미 설정해 놓은 다른 모든 Emacs 관련 기능을 사용하세요.

Searching through M-x list-packages for “zettel” brings up more matches. zetteldesk is an extension to Org Roam and, as such, I cannot possibly know what Org Roam truly misses and what the added-value of this package is. neuron-mode builds on top of an external program called neuron, which I have never used.

M-x list-packages 에서 "zettel"을 검색하면 더 많은 일치 항목을 찾을 수 있습니다. zetteldesk 은 Org Roam 의 확장 프로그램이기 때문에 Org Roam 이 진정으로 놓치고 있는 것이 무엇인지, 이 패키지의 부가 가치가 무엇인지 알 수 없습니다. neuron-mode 은 neuron 이라는 외부 프로그램 위에 구축되어 있는데, 저는 이 프로그램을 사용해 본 적이 없습니다.

Searching for “note” gives us a few more results. notes-mode has precious little documentation and I cannot tell what it actually does (as I said in my presentation for LibrePlanet 2022, inadequate docs are a bug). side-notes differs from what we try to do with Denote, as it basically gives you the means to record your thoughts about some other project you are working on and keep them on the side: so it and Denote should not be mutually exclusive.

notes-mode 에는 문서가 거의 없고 실제로 어떤 기능을 하는지 알 수 없습니다(제가 LibrePlanet 2022 프레젠테이션에서 말했듯이 문서가 충분하지 않은 것은 버그입니다). side-notes 은 기본적으로 작업 중인 다른 프로젝트에 대한 생각을 기록하고 보관할 수 있는 수단을 제공한다는 점에서 우리가 Denote 로 하려는 것과는 다릅니다.

If I missed something, please let me know.

제가 놓친 것이 있으면 알려주세요.

21.1. Alternative implementations and further reading

21.1. 대체 구현 및 추가 자료

This section covers blog posts and implementations from the Emacs community about the topic of note-taking and file organization. They may refer to some of the packages covered in the previous section or provide their custom code (). The list is unsorted.

이 섹션에서는 노트 필기 및 파일 정리를 주제로 한 Emacs 커뮤니티의 블로그 게시물과 구현 사례를 다룹니다. 이전 섹션에서 다룬 패키지 중 일부를 참조하거나 사용자 지정 코드를 제공할 수도 있습니다('표시의 대안'). 목록은 정렬되지 않았습니다.

• José Antonio Ortega Ruiz (aka “jao”) explains a note-taking method that is simple like Denote but differs in other ways. An interesting approach overall: https://jao.io/blog/simple-note-taking.html.

  José Antonio Ortega Ruiz(일명 "jao")가 Denote 처럼 간단하지만 다른 방식으로 다른 노트 필기 방법을 설명합니다. 전반적으로 흥미로운 접근법: https://jao.io/blog/simple-note-taking.html.

• Jethro Kuan (the main org-roam developer) explains their note-taking techniques: https://jethrokuan.github.io/org-roam-guide/. Good ideas all round, regardless of the package/code you choose to use.

  Jethro Kuan( org-roam 메인 개발자)이 노트 필기 기법에 대해 설명합니다: https://jethrokuan.github.io/org-roam-guide/. 어떤 패키지/코드를 사용하든 모두 좋은 아이디어입니다.

• Karl Voit's tools date2name, filetags, appendfilename, and move2archive provide a Python-based implementation to organize individual files which do not require Emacs. His approach (blog post and his presentation at GLT18) has been complemented by memacs to process e.g., the date of creation of photographs, or the log of a phone call in a format compatible to org.

  Karl Voit 의 도구인 date2name, filetags, appendfilename, move2archive 는 이맥이 필요 없는 개별 파일을 정리할 수 있는 Python 기반 구현을 제공합니다. 그의 접근 방식(블로그 게시물 및 GLT18 에서의 프레젠테이션)은 사진의 생성 날짜나 전화 통화 기록 등을 조직과 호환되는 형식으로 처리하기 위해 memacs 로 보완되었습니다.

[ Development note: help expand this list. ]

[ 개발 참고: 이 목록을 확장하는 데 도움이 됩니다.]

22. Frequently Asked Questions

자주 묻는 질문

I (Protesilaos) answer some questions I have received or might get. It is assumed that you have read the rest of this manual: I will not go into the specifics of how Denote works.

저(프로테실로스)는 제가 받았거나 받을 수 있는 몇 가지 질문에 답합니다. 이 설명서의 나머지 부분을 읽으셨다고 가정합니다: Denote 의 작동 방식에 대한 구체적인 내용은 다루지 않겠습니다.

22.1. Why develop Denote when PACKAGE already exists?

22.1. 이미 패키지가 존재하는데 왜 Denote 를 개발해야 하나요?

I wrote Denote because I was using a variant of Denote's file-naming scheme before I was even an Emacs user (I switched to Emacs from Tmux+Vim+CLI in the summer of 2019). I was originally inspired by Jekyll, the static site generator, which I started using for my website in 2016 (was on WordPress before). Jekyll's files follow the YYYY-MM-DD-TITLE.md pattern. I liked its efficiency relative to the unstructured mess I had before. Eventually, I started using that scheme outside the confines of my website's source code. Over time I refined it and here we are.

제가 Denote 를 쓴 이유는 Emacs 사용자가 되기 전부터 Denote 의 변형된 파일 명명 체계를 사용하고 있었기 때문입니다(2019 년 여름에 Tmux+Vim+CLI 에서 Emacs 로 전환했습니다). 저는 원래 2016 년에 제 웹사이트에 사용하기 시작한 정적 사이트 생성기인 지킬에서 영감을 받았습니다(이전에는 워드프레스를 사용했었죠). 지킬의 파일은 YYYY-MM-DD-TITLE.md 패턴을 따릅니다. 이전에 사용하던 구조화되지 않은 엉망진창에 비해 효율성이 마음에 들었습니다. 결국 웹사이트 소스 코드의 범위 밖에서도 이 방식을 사용하기 시작했습니다. 시간이 지남에 따라 이 방식을 다듬어 지금에 이르렀습니다.

Note-taking is something I take very seriously, as I am a prolific writer (just check my website, which only reveals the tip of the iceberg). As such, I need a program that does exactly what I want and which I know how to extend. I originally tried to use Org capture templates to create new files with a Denote-style file-naming scheme but never managed to achieve it. Maybe because org-capture has some hard-coded assumptions or I simply am not competent enough to hack on core Org facilities. Whatever the case, an alternative was in order.

저는 다작을 하는 작가이기 때문에 노트 필기를 매우 중요하게 생각합니다(빙산의 일각만 보여주는 제 웹사이트를 확인해 보세요). 따라서 제가 원하는 기능을 정확히 수행하고 확장하는 방법을 알고 있는 프로그램이 필요합니다. 원래는 조직 캡처 템플릿을 사용하여 Denote 스타일의 파일 명명 체계로 새 파일을 만들려고 했지만 성공하지 못했습니다. org-capture 에 하드코딩된 가정이 있거나 제가 핵심 조직 기능을 해킹할 만큼 능력이 부족하기 때문일 수도 있습니다. 어떤 경우든 대안이 필요했습니다.

The existence of PACKAGE is never a good reason for me not to conduct my own experiments for recreational, educational, or practical purposes. When the question arises of “why not contribute to PACKAGE instead?” the answer is that without me experimenting in the first place, I would lack the skills for such a task. Furthermore, contributing to another package does not guarantee I get what I want in terms of workflow.

PACKAGE 의 존재는 제가 여가, 교육 또는 실용적인 목적으로 직접 실험을 수행하지 않을 좋은 이유가 될 수 없습니다. "왜 PACKAGE 에 기여하지 않는가?"라는 질문이 생기면, 애초에 제가 실험을 하지 않으면 그러한 작업에 필요한 기술이 부족하기 때문이라고 답할 수 있습니다. 게다가 다른 패키지에 기여한다고 해서 워크플로 측면에서 제가 원하는 것을 얻을 수 있다는 보장은 없습니다.

Whether you should use Denote or not is another matter altogether: choose whatever you want.

Denote 를 사용할지 여부는 완전히 다른 문제이므로 원하는 것을 선택하세요.

22.2. Why not rely exclusively on Org?

22.2. Org 에만 의존하지 않으시겠습니까?

I think Org is one of Emacs' killer apps. I also believe it is not the right tool for every job. When I write notes, I want to focus on writing. Nothing more. I thus have no need for stuff like org-babel, scheduling to-do items, clocking time, and so on. The more “mental dependencies” you add to your workflow, the heavier the burden you carry and the less focused you are on the task at hand: there is always that temptation to tweak the markup, tinker with some syntactic construct, obsess about what ought to be irrelevant to writing as such.

저는 Org 가 Emacs 의 킬러 앱 중 하나라고 생각합니다. 하지만 모든 업무에 적합한 도구는 아니라고 생각합니다. 저는 노트를 작성할 때 글쓰기에 집중하고 싶어요. 그 이상은 필요 없습니다. 따라서 저는 할 일 목록, 할 일 스케줄링, 시간 체크 같은 것들은 필요 없습니다. 워크플로우에 "정신적 종속성"을 더 많이 추가할수록 부담은 더 무거워지고 당면한 작업에 집중할 수 없게 됩니다. 마크업을 수정하고, 구문 구조를 땜질하고, 글쓰기와는 상관없는 것에 집착하고 싶은 유혹이 항상 존재하기 마련입니다.

In technical terms, I also am not fond of Org's code base (I understand why it is the way it is---just commenting on the fact). Ever tried to read it? You will routinely find functions that are tens-to-hundreds of lines long and have all sorts of special casing. As I am not a programmer and only learnt to write Elisp through trial and error, I have no confidence in my ability to make Org do what I want at that level, hence denote instead of org-denote or something.

기술적인 측면에서 저는 Org 의 코드 기반도 마음에 들지 않습니다(왜 그런지 이해합니다. 단지 사실에 대해 언급하는 것뿐입니다). 읽어보신 적이 있나요? 수십에서 수백 줄에 달하는 함수를 일상적으로 찾을 수 있으며 모든 종류의 특수 대소문자가 있습니다. 저는 프로그래머가 아니고 시행착오를 통해서만 Elisp 를 배웠기 때문에 그 수준에서 Org 가 원하는 것을 수행하도록 만들 수 있다는 자신감이 없기 때문에 org-denote 대신 denote .

Perhaps the master programmer is one who can deal with complexity and keep adding to it. I am of the opposite view, as language---code included---is at its communicative best when it is clear and accessible.

아마도 마스터 프로그래머는 복잡성을 처리하고 계속 추가할 수 있는 사람일 것입니다. 저는 정반대의 견해를 가지고 있습니다. 언어(코드 포함)는 명확하고 접근하기 쉬울 때 의사소통이 가장 잘 이루어지기 때문입니다.

Make no mistake: I use Org for the agenda and also to write technical documentation that needs to be exported to various formats, including this very manual.

오해하지 마세요. 저는 의제를 정하고 이 매뉴얼을 포함하여 다양한 형식으로 내보내야 하는 기술 문서를 작성할 때에도 Org 를 사용합니다.

22.3. Why care about Unix tools when you use Emacs?

22.3. Emac 을 사용하는데 왜 유닉스 도구에 신경을 써야 할까요?

My notes form part of my longer-term storage. I do not want to have to rely on a special program to be able to read them or filter them. Unix is universal, at least as far as I am concerned.

제 노트는 제 장기 보관함의 일부가 됩니다. 노트를 읽거나 필터링하기 위해 특별한 프로그램에 의존하고 싶지 않습니다. 적어도 제가 아는 한 유닉스는 보편적입니다.

Denote streamlines some tasks and makes things easier in general, which is consistent with how Emacs provides a layer of interactivity on top of Unix. Still, Denote's utilities can, in principle, be implemented as POSIX shell scripts (minus the Emacs-specific parts like fontification in Dired or the buttonization of links).

Denote 는 일부 작업을 간소화하고 일반적으로 작업을 더 쉽게 만들어 주는데, 이는 Emacs 가 유닉스 위에 상호 작용 계층을 제공하는 방식과 일치합니다. 하지만 Denote 의 유틸리티는 원칙적으로 POSIX 셸 스크립트로 구현할 수 있습니다(Dired 의 글꼴화나 링크의 버튼화와 같은 Emacs 전용 부분을 제외하면).

Portability matters. For example, in the future I might own a smartphone, so I prefer not to require Emacs, Org, or some other executable to access my files on the go.

휴대성이 중요합니다. 예를 들어, 앞으로 스마트폰을 소유하게 될지도 모르기 때문에 이동 중에 파일에 액세스하기 위해 Emacs, Org 또는 기타 실행 파일이 필요하지 않기를 원합니다.

Furthermore, I might want to share those files with someone. If I make Emacs a requirement, I am limiting my circle to a handful of relatively advanced users.

또한 이러한 파일을 다른 사람과 공유하고 싶을 수도 있습니다. Emac 을 필수로 설정하면 비교적 고급 사용자 몇 명으로 서클을 제한하게 됩니다.

Please don't misinterpret this: I am using Emacs full-time for my computing and maintain a growing list of packages for it. This is just me thinking long-term.

오해하지 마세요: 저는 컴퓨팅에 Emacs 를 풀타임으로 사용하고 있으며, 이를 위한 패키지 목록도 계속 늘려가고 있습니다. 이것은 제가 장기적으로 생각하는 것입니다.

22.4. Why many small files instead of few large ones?

22.4. 대용량 파일이 적은 대신 작은 파일이 많은 이유는 무엇인가요?

I have read that Org favours the latter method. If true, I strongly disagree with it because of the implicit dependency it introduces and the way it favours machine-friendliness over human-readability in terms of accessing information. Notes are long-term storage. I might want to access them on (i) some device with limited features, (ii) print on paper, (iii) share with another person who is not a tech wizard.

조직이 후자의 방법을 선호한다는 글을 읽었습니다. 사실이라면 암묵적인 종속성을 야기하고 정보에 접근하는 데 있어 사람이 가독성을 높이기보다 기계 친화성을 선호한다는 점에서 저는 이 방식에 강력히 반대합니다. 노트는 장기 보관 자료입니다. (i) 기능이 제한된 일부 장치에서 액세스하거나, (ii) 종이에 인쇄하거나, (iii) 기술 전문가가 아닌 다른 사람과 공유하고 싶을 수도 있습니다.

There are good arguments for few large files, but all either prioritize machine-friendliness or presuppose the use of sophisticated tools like Emacs+Org.

몇 가지 대용량 파일에 대한 좋은 주장이 있지만, 모두 기계 친화성을 우선시하거나 Emacs+Org 와 같은 정교한 도구의 사용을 전제로 합니다.

Good luck using less on a generic TTY to read a file with a zillion words, headings, sub-headings, sub-sub-headings, property drawers, and other constructs! You will not get the otherwise wonderful folding of headings the way you do in Emacs---do not take such features for granted.

일반 TTY 에서 less 를 사용하여 수많은 단어, 제목, 하위 제목, 하위 하위 제목, 속성 서랍 및 기타 구조가 있는 파일을 읽어 보세요! Emacs 에서와 같은 멋진 머리글 접기 기능을 사용할 수 없으므로 이러한 기능을 당연하게 생각하지 마세요.

My point is that notes should be atomic to help the user---and potentially the user's family, friends, acquaintances---make sense of them in a wide range of scenaria. The more program-agnostic your file is, the better for you and/or everyone else you might share your writings with.

제 요점은 사용자와 사용자의 가족, 친구, 지인들이 다양한 상황에서 노트를 이해할 수 있도록 노트가 원자적이어야 한다는 것입니다. 파일은 프로그램에 구애받지 않을수록 사용자 자신과 글을 공유할 수 있는 다른 모든 사람들에게 더 좋습니다.

Human-readability means that we optimize for what matters to us. If (a) you are the only one who will ever read your notes, (b) always have access to good software like Emacs+Org, (c) do not care about printing on paper, then Denote's model is not for you. Maybe you need to tweak some org-capture template to append a new entry to one mega file (I do that for my Org agenda, by the way, as I explained before about using the right tool for the job).

사람이 읽을 수 있다는 것은 우리에게 중요한 것에 최적화되어 있다는 뜻입니다. (가) 노트를 읽을 사람이 본인뿐이고, (나) 항상 Emacs+Org 같은 좋은 소프트웨어에 액세스할 수 있고, (다) 종이에 인쇄하는 것에 신경 쓰지 않는다면 Denote 의 모델은 적합하지 않을 수 있습니다. 어쩌면 org-capture 템플릿을 조정해 하나의 대용량 파일에 새 항목을 추가해야 할지도 모릅니다(앞서 작업에 적합한 도구 사용에 대해 설명했듯이 저는 조직 안건에 대해 이 작업을 수행합니다).

22.5. Does Denote perform well at scale?

22.5. Denote 는 규모에 맞게 잘 작동하나요?

Denote does not do anything fancy and has no special requirements: it uses standard tools to accomplish ordinary tasks. If Emacs can cope with lots of files, then that is all you need to know: Denote will work.

Denote 는 특별한 요구 사항이 없으며 표준 도구를 사용하여 일반적인 작업을 수행합니다. Emacs 가 많은 파일에 대처할 수 있다면 그것만 알면 됩니다: Denote 가 작동합니다.

To put this to the test, Peter Prevos is running simulations with R that generate large volumes of notes. You can read the technicalities here: https://lucidmanager.org/productivity/testing-denote-package/. Excerpt:

이를 테스트하기 위해 Peter Prevos 는 R 을 사용해 대량의 노트를 생성하는 시뮬레이션을 실행하고 있습니다. 자세한 내용은 https://lucidmanager.org/productivity/testing-denote-package/ 에서 확인할 수 있습니다. 발췌:

Using this code I generated ten thousands notes and used this to test the Denote package to see it if works at a large scale. This tests shows that Prot's approach is perfectly capable of working with thousands of notes.

이 코드를 사용해 수만 개의 노트를 생성하고 이를 사용해 Denote 패키지가 대규모로 작동하는지 테스트했습니다. 이 테스트는 Prot 의 접근 방식이 수천 개의 노트를 완벽하게 처리할 수 있음을 보여줍니다.

Of course, we are always prepared to make refinements to the code, where necessary, without compromising on the project's principles.

물론 필요한 경우 프로젝트의 원칙을 훼손하지 않는 범위 내에서 언제든지 코드를 개선할 준비가 되어 있습니다.

22.6. I add TODOs to my notes; will many files slow down the Org agenda?

22.6. 노트에 할 일을 추가하는데, 파일이 많으면 조직 안건 처리 속도가 느려지나요?

Yes, many files will slow down the agenda due to how that works. Org collects all files specified in the org-agenda-files, searches through their contents for timestamped entries, and then loops through all days to determine where each entry belongs. The more days and more files, the longer it takes to build the agenda. Doing this with potentially hundreds of files will have a noticeable impact on performance.

예, 작동 방식 때문에 많은 파일로 인해 안건 처리 속도가 느려질 수 있습니다. Org 는 org-agenda-files 에 지정된 모든 파일을 수집하여 콘텐츠에서 타임스탬프가 지정된 항목을 검색한 다음, 모든 날짜를 반복하여 각 항목이 속한 위치를 확인합니다. 일수가 많고 파일이 많을수록 안건을 작성하는 데 시간이 오래 걸립니다. 수백 개의 파일로 이 작업을 수행하면 성능에 눈에 띄는 영향을 미칩니다.

This is not a deficiency of Denote. It happens with generic Org files. The way the agenda is built is heavily favoring the use of a single file that holds all your timestamped entries (or at least a few such files). Tens or hundreds of files are inefficient for this job. Plus doing so has the side-effect of making Emacs open all those files, which you probably do not need.

이것은 Denote 의 결함이 아닙니다. 일반적인 조직 파일에서 발생하는 문제입니다. 아젠다를 구축하는 방식은 타임스탬프가 찍힌 모든 항목(또는 최소한 몇 개의 파일)을 포함하는 단일 파일을 사용하는 것을 크게 선호합니다. 수십, 수백 개의 파일은 이 작업에 비효율적입니다. 게다가 그렇게 하면 굳이 필요하지 않은 파일까지 모두 Emac 에서 열어야 하는 부작용이 있습니다.

If you want my opinion though, be more forceful with the separation of concerns. Decouple your knowledge base from your ephemeral to-do list: Denote (and others) can be used for the former, while you let standard Org work splendidly for the latter---that is what I do, anyway.

제 의견을 말씀드리자면, 우려 사항을 더 강력하게 분리하세요. 지식창고를 일시적인 할 일 목록에서 분리하세요: 전자의 경우 Denote(및 기타)를 사용하고, 후자의 경우 표준 조직이 훌륭하게 작동하도록 두는 것이 제가 하는 방식입니다.

Org has a powerful linking facility, whether you use org-store-link or do it via an org-capture template. If you want a certain note to be associated with a task, just store the task in a single tasks.org (or however you name it) and link to the relevant context.

Org 에는 org-store-link 를 사용하든 org-capture 템플릿을 사용하든 강력한 링크 기능이 있습니다. 특정 노트를 작업과 연결하고 싶은 경우, 작업을 하나의 tasks.org (또는 원하는 이름)에 저장하고 관련 컨텍스트에 링크하면 됩니다.

Do not mix your knowledge base with your to-do items. If you need help figuring out the specifics of this workflow, you are welcome to ask for help in our relevant channels ().

지식창고와 할 일 항목을 혼용하지 마세요. 이 워크플로우의 구체적인 내용을 파악하는 데 도움이 필요하면 관련 채널(기여하기)에서 도움을 요청하세요.

22.7. I want to sort by last modified, why won't Denote let me?

22.7. 마지막으로 수정한 날짜별로 정렬하고 싶은데 왜 Denote 에서 허용하지 않나요?

Denote does not sort files and will not reinvent tools that handle such functionality. This is the job of the file manager or command-line executable that lists files.

Denote 는 파일을 정렬하지 않으며 이러한 기능을 처리하는 도구를 재창조하지 않습니다. 이는 파일을 나열하는 파일 관리자 또는 명령줄 실행 파일이 하는 일입니다.

I encourage you to read the manpage of the ls executable. It will help you in general, while it applies to Emacs as well via Dired. The gist is that you can update the ls flags that Dired uses on-the-fly: type C-u M-x dired-sort-toggle-or-edit (C-u s by default) and append --sort=time at the prompt. To reverse the order, add the -r flag. The user option dired-listing-switches sets your default preference.

ls 실행 파일의 매뉴얼 페이지를 읽어보시기 바랍니다. 일반적으로 도움이 될 것이며, Dired 를 통해 Emac 에도 적용됩니다. 요점은 Dired 가 사용하는 ls 플래그를 즉석에서 업데이트할 수 있다는 것입니다. C-u M-x dired-sort-toggle-or-edit (기본값은 C-u s )을 입력하고 프롬프트에 --sort=time 을 추가하면 됩니다. 순서를 바꾸려면 -r 플래그를 추가하세요. 사용자 옵션 dired-listing-switches 은 기본 기본 설정을 설정합니다.

There is also “virtual Dired” if you need something that cannot be done with Dired ().

Dired 로 할 수 없는 작업이 필요한 경우 "가상 Dired"도 있습니다(임의의 파일 목록에는 dired-virtual-mode 사용).

22.8. How do you handle the last modified case?

22.8. 마지막으로 수정된 케이스는 어떻게 처리하나요?

Denote does not insert any meta data or heading pertaining to edits in the file. I am of the view that these either do not scale well or are not descriptive enough. Suppose you use a “lastmod” heading with a timestamp: which lines where edited and what did the change amount to?

Denote 는 파일에 편집과 관련된 메타 데이터나 제목을 삽입하지 않습니다. 이는 확장성이 좋지 않거나 충분히 설명적이지 않다고 생각합니다. 타임스탬프가 있는 "lastmod" 제목을 사용한다고 가정해 보겠습니다. 어떤 줄이 편집되었고 변경된 내용이 무엇인지 알 수 있을까요?

This is where an external program can be helpful. Use a Version Control System, such as Git, to keep track of all your notes. Every time you add a new file, record the addition. Same for post-creation edits. Your VCS will let you review the history of those changes. For instance, Emacs' built-in version control framework has a command that produces a log of changes for the current file: M-x vc-print-log, bound to C-x v l by default. From there one can access the corresponding diff output (use M-x describe-mode (C-h m) in an unfamiliar buffer to learn more about it). With Git in particular, Emacs users have the option of the all-round excellent magit package.

이때 외부 프로그램이 도움이 될 수 있습니다. Git 과 같은 버전 관리 시스템을 사용해 모든 노트를 추적하세요. 새 파일을 추가할 때마다 추가 내용을 기록하세요. 생성 후 편집할 때도 마찬가지입니다. VCS 를 사용하면 변경 내역을 검토할 수 있습니다. 예를 들어, Emacs 의 기본 버전 제어 프레임워크에는 현재 파일의 변경 로그를 생성하는 명령이 있습니다: M-x vc-print-log 기본적으로 C-x v l 에 바인딩됩니다. 여기에서 해당 diff 출력에 액세스할 수 있습니다(자세한 내용은 M-x describe-mode ( C-h m )를 참조하세요). 특히 Git 을 사용하는 Emacs 사용자에게는 다재다능한 magit 패키지를 선택할 수 있습니다.

In short: let Denote (or equivalent) create notes and link between them, the file manager organise and provide access to files, search programs deal with searching and narrowing, and version control software handle the tracking of changes.

간단히 말해, Denote(또는 이와 동등한 기능)가 노트를 만들고 노트 사이를 연결하고, 파일 관리자가 파일을 정리하고 액세스를 제공하고, 검색 프로그램이 검색과 검색 범위를 좁히고, 버전 관리 소프트웨어가 변경 사항 추적을 처리하도록 맡기세요.

22.9. Speed up backlinks' buffer creation?

22.9. 백링크의 버퍼 생성 속도를 높이시겠습니까?

Denote leverages the built-in xref library to search for the identifier of the current file and return any links to it. For users of Emacs version 28 or higher, there exists a user option to specify the program that performs this search: xref-search-program. The default is grep, which can be slow, though one may opt for ugrep, ripgrep, or even specify something else (read the doc string of that user option for the details).

Denote 는 내장된 xref 라이브러리를 활용하여 현재 파일의 식별자를 검색하고 해당 파일에 대한 링크를 반환합니다. Emacs 버전 28 이상 사용자의 경우 이 검색을 수행하는 프로그램을 지정할 수 있는 사용자 옵션이 있습니다( xref-search-program ). 기본값은 grep 이며, 속도가 느릴 수 있지만 ugrep , ripgrep 또는 다른 것을 지정할 수도 있습니다(자세한 내용은 해당 사용자 옵션의 문서 문자열을 참조하세요).

Try either for these for better results:

더 나은 결과를 얻으려면 이 두 가지를 시도해 보세요:

(setq xref-search-program 'ripgrep)
 
;; OR
 
(setq xref-search-program 'ugrep)

To use whatever executable is available on your system, use something like this:

시스템에서 사용 가능한 실행 파일을 사용하려면 다음과 같은 것을 사용하세요:

;; Prefer ripgrep, then ugrep, and fall back to regular grep.
(setq xref-search-program
      (cond
       ((or (executable-find "ripgrep")
            (executable-find "rg"))
        'ripgrep)
       ((executable-find "ugrep")
        'ugrep)
       (t
        'grep)))

22.10. Why do I get “Search failed with status 1” when I search for backlinks?

22.10. 백링크를 검색할 때 '상태 1 로 검색 실패'라는 메시지가 표시되는 이유는 무엇인가요?

Denote uses Emacs' Xref to find backlinks. Xref requires xargs and one of grep or ripgrep, depending on your configuration.

Denote 는 Emacs 의 Xref 를 사용하여 백링크를 찾습니다. Xref 에는 설정에 따라 xargs 및 grep 또는 ripgrep 중 하나가 필요합니다.

This is usually not an issue on *nix systems, but the necessary executables are not available on Windows Emacs distributions. Please ensure that you have both xargs and either grep or ripgrep available within your PATH environment variable.

일반적으로 *nix 시스템에서는 문제가 되지 않지만, Windows Emacs 배포판에서는 필요한 실행 파일을 사용할 수 없습니다. PATH 환경 변수에 xargs 및 grep 또는 ripgrep 중 하나를 모두 사용할 수 있는지 확인하세요.

If you have git on Windows installed, then you may use the following code (adjust the git's installation path if necessary):

Windows 에 git 가 설치되어 있는 경우 다음 코드를 사용할 수 있습니다(필요한 경우 git 의 설치 경로를 조정하세요):

  (setenv "PATH" (concat (getenv "PATH") ";" "C:\\Program Files\\Git\\usr\\bin"))

23. Acknowledgements

Denote is meant to be a collective effort. Every bit of help matters.

Denote 는 공동의 노력을 의미합니다. 모든 도움이 중요합니다.

Author/maintainer작성자/관리자 : Protesilaos Stavrou.프로테실라오스 스타브로.

Contributions to code or the manual

코드 또는 매뉴얼에 대한 기여 :: Abin Simon, Adam Růžička, Alan Schmitt, Benjamin Kästner, Bruno Boal, Charanjit Singh, Clemens Radermacher, Colin McLear, Damien Cassou, Eduardo Grajeda, Elias Storms, Eshel Yaron, Florian, Graham Marlow, Hilde Rhyne, Ivan Sokolov, Jack Baty, Jean-Charles Bagneris, Jean-Philippe Gagné Guay, Jürgen Hötzel, Kaushal Modi, Kai von Fintel, Kostas Andreadis, Kyle Meyer, Marc Fargas, Matthew Lemon, Noboru Ota (nobiot), Norwid Behrnd, Peter Prevos, Philip Kaludercic, Quiliro Ordóñez, Stefan Monnier, Stefan Thesing, Thibaut Benjamin, Tomasz Hołubowicz, Vedang Manerikar, ezchi, mentalisttraceur, relict007.

아빈 사이먼, 아담 로치카, 알란 슈미트, 벤자민 케스트너, 브루노 보알, 차란짓 싱, 클레멘스 라더마허, 콜린 맥리어, 데미안 카수, 에두아르도 그라제다, 엘리아스 스톰스, 에셀 야론, 플로리안, 그레이엄 말로우, 힐데 라인, 이반 소콜로프, 잭 바티, 장 샤를 바네리스, 장 필립 가네 과이, 유르겐 회첼, Kaushal Modi, Kai von Fintel, Kostas Andreadis, Kyle Meyer, Marc Fargas, Matthew Lemon, Noboru Ota(nobiot), Norwid Behrnd, Peter Prevos, Philip Kaludercic, Quiliro Ordóñez, Stefan Monnier, Stefan Thesing, Thibaut Benjamin, Tomasz Hołubowicz, Vedang Manerikar, ezchi, mentalisttraceur, relict007.

Ideas and/or user feedback

아이디어 및/또는 사용자 피드백 :: Abin Simon, Aditya Yadav, Alan Schmitt, Alfredo Borrás, Ashton Wiersdorf, Benjamin Kästner, Colin McLear, Damien Cassou, Elias Storms, Federico Stilman, Florian, Frédéric Willem Frank Ehmsen, Guo Yong, Hanspeter Gisler, Jack Baty, Jay Rajput, Jean-Charles Bagneris, Jens Östlund, Jeremy Friesen, Jonathan Sahar, Johan Bolmsjö, Juanjo Presa, Kai von Fintel, Kaushal Modi, M. Hadi Timachi, Mark Olson, Mirko Hernandez, Niall Dooley, Paul van Gelder, Peter Prevos, Peter Smith, Suhail Singh, Shreyas Ragavan, Stefan Thesing, Summer Emacs, Sven Seebeck, Taoufik, TJ Stankus, Viktor Haag, Wade Mealing, Yi Liu, Ypot, atanasj, doolio, drcxd, hpgisler, pRot0ta1p, rbenit68, relict007, sienic, sundar bp.

아빈 사이먼, 아디트야다브, 알란 슈미트, 알프레도 보라스, 애쉬튼 비어스도르프, 벤자민 케스트너, 콜린 맥리어, 데미안 카수, 엘리아스 스톰스, 페데리코 스틸만, 플로리안, 프레데릭 빌렘 프랭크 윔센, Guo Yong, Hanspeter Gisler, Jack Baty, Jay Rajput, Jean-Charles Bagneris, Jens Östlund, Jeremy Friesen, Jonathan Sahar, Johan Bolmsjö, Juanjo Presa, Kai von Fintel, Kaushal Modi, M.. Hadi Timachi, Mark Olson, Mirko Hernandez, Niall Dooley, Paul van Gelder, Peter Prevos, Peter Smith, Suhail Singh, Shreyas Ragavan, Stefan Thesing, Summer Emacs, Sven Seebeck, Taoufik, TJ Stankus, Viktor Haag, Wade Mealing, Yi Liu, Ypot, atanasj, doolio, drcxd, hpgisler, pRot0ta1p, rbenit68, relict007, sienic, sundar bp.

Special thanks to Peter Povinec who helped refine the file-naming scheme, which is the cornerstone of this project.

이 프로젝트의 초석이 된 파일 이름 지정 체계를 개선하는 데 도움을 준 Peter Povinec 에게 특별히 감사드립니다.

Special thanks to Jean-Philippe Gagné Guay for the numerous contributions to the code base.

코드 베이스에 많은 기여를 해주신 장 필립 가녜 가이에게 특별히 감사드립니다.

Related-Notes

References