Инструкция по работе с git markdown

Создавайте расширенное форматирование текста и кода в GitHub с помощью простого синтаксиса.

Заголовки

Чтобы создать заголовок, добавьте от одного до шести символов # перед его текстом. Количество используемых # элементов определяет уровень иерархии и размер шрифта заголовка.

# A first-level heading
## A second-level heading
### A third-level heading

Снимок экрана: отрисованный GitHub Markdown с примерами заголовков h1, h2 и h3, которые уходят по размеру типа и визуальному весу для указания убывающей иерархии.

При использовании двух или более заголовков GitHub автоматически создает оглавление, к которому можно получить доступ, щелкнув в заголовке файла. В оглавлении приводится каждый заголовок. Щелкнув по нему, можно перейти к соответствующему разделу.

Снимок экрана: файл сведений в репозитории открытый код документации GitHub с раскрывающимся меню для оглавлением. Значок оглавлиния выделен темно-оранжевым цветом.

Выделение текста

Текст в полях комментариев и файлах .md можно выделять полужирным шрифтом, курсивом, зачеркиванием, а также подстрочным или надстрочным шрифтом.

Стиль Синтаксис Сочетания клавиш Пример Выходные данные
Полужирный шрифт ** ** или __ __ COMMAND+B (Mac) или CTRL+B (Windows и Linux) **This is bold text** Это полужирный текст
Курсив * * или _ _      COMMAND+I (Mac) или CTRL+I (Windows и Linux) *This text is italicized* Этот курсивный текст
Зачеркнутый ~~ ~~ ~~This was mistaken text~~ Это был неправильный текст
Полужирный и вложенный курсив ** ** и _ _ **This text is _extremely_ important** Этот текст очень важен
Весь полужирный и курсивный *** *** ***All this text is important*** Весь этот текст важен
Подстрочный <sub> </sub> <sub>This is a subscript text</sub> Это подстрочный текст
Надстрочный <sup> </sup> <sup>This is a superscript text</sup> Это надстрочный текст

Текст в кавычках

Цитировать текст можно с помощью >.

Text that is not a quote

> Text that is a quote

Текст в кавычках имеет отступ с другим цветом типа.

Снимок экрана: отрисованный GitHub Markdown с примером текста в кавычках. Кавычка имеет отступ с вертикальной линией слева, а ее текст будет темно-серым, а не черным.

Совет. Текст из беседы можно автоматически цитировать в комментарии. Для этого выделите текст и введите R. Чтобы процитировать весь комментарий, щелкните значок и выберите пункт Цитировать в ответе. Дополнительные сведения о сочетаниях клавиш см. в разделе сочетания клавиш.

Цитирование кода

Вы можете выделить код или команду в предложении с помощью одинарных грависов. Текст, заключенный в обратные кавычки, не форматируется. Кроме того, вы можете использовать сочетание клавиш COMMAND+E (Mac) или CTRL+E (Windows/Linux) для вставки обратных кавычек для блока кода в строке Markdown.

Use `git status` to list all new or modified files that haven't yet been committed.

Снимок экрана: отрисованный GitHub Markdown, показывающий внешний вид символов, окруженных обратными знаками. Слова "состояние Git" отображаются в шрифте фиксированной ширины, выделенном светло-серым цветом.

Чтобы выделить код или текст в отдельный блок, используйте тройные грависы.

Some basic Git commands are:
```
git status
git add
git commit
```

Снимок экрана: отрисованный GitHub Markdown с блоком кода. Слова "git status", "git add" и "git commit" отображаются в шрифте фиксированной ширины, выделенном светло-серым цветом.

Дополнительные сведения см. в разделе Создание и выделение блоков кода.

Если вы часто редактируете фрагменты кода и таблицы, может быть удобно включить моноширинный шрифт во всех полях комментариев в GitHub. Дополнительные сведения см. в разделе Сведения о написании и форматировании текста на GitHub.

Поддерживаемые цветовые модели

В сообщениях о проблемах, запросах на вытягивание и обсуждениях можно вызывать цвета в предложении, используя обратные кавычки. Поддерживаемая цветовая модель, заключенная в обратные кавычки, будет отображать визуализацию цвета.

The background color is `#ffffff` for light mode and `#000000` for dark mode.

Снимок экрана: отрисованный GitHub Markdown, показывающий, как шестнадцатеричные значения в обратных чертах создают маленькие круги цвета. #ffffff отображает белый круг, а #000000 — черный.

Ниже указаны поддерживаемые сейчас цветовые модели.

Цвет Синтаксис Пример Выходные данные
HEX `#RRGGBB` `#0969DA` Снимок экрана: отрисованный GitHub Markdown, показывающий, как #0969DA шестнадцатеричное значение с синим кругом.
RGB `rgb(R,G,B)` `rgb(9, 105, 218)` Снимок экрана: отрисованный GitHub Markdown, показывающий, как rgb-значение 9, 105, 218 отображается с синим кругом.
HSL `hsl(H,S,L)` `hsl(212, 92%, 45%)` Снимок экрана: отрисованный GitHub Markdown, показывающий, как значение HSL 212, 92%, 45 % отображается синим кругом.

Примечания.

  • Поддерживаемая цветовая модель не может содержать начальные или конечные пробелы между обратными кавычками.
  • Визуализация цвета поддерживается только в сообщениях о проблемах, запросах на вытягивание и обсуждениях.

Ссылки

Чтобы создать встроенную ссылку, заключите ее текст в квадратные скобки [ ], а затем заключите URL-адрес в обычные скобки ( ). Для создания ссылки также можно использовать сочетание клавиш Команда+K . Выбрав текст, вы можете вставить URL-адрес из буфера обмена, чтобы автоматически создать ссылку из выделенного фрагмента.

Вы также можете создать гиперссылку Markdown, выделив текст и используя сочетание клавиш Command+V. Если вы хотите заменить текст ссылкой, используйте сочетание клавиш COMMAND+SHIFT+V.

This site was built using [GitHub Pages](https://pages.github.com/).

Снимок экрана: отрисованный GitHub Markdown, показывающий, как текст в квадратных скобках "Страницы GitHub" отображается в виде синей гиперссылки.

Совет. GitHub автоматически создает ссылки при вводе допустимых URL-адресов в комментариях. Дополнительные сведения см. в разделе Автосвязанные ссылки и URL-адреса.

Ссылки на разделы

Вы можете создать ссылку непосредственно на раздел в отрисованном файле, наведите указатель мыши на заголовок раздела, чтобы открыть .

Снимок экрана: файл сведений для репозитория. Слева от заголовка раздела значок ссылки выделен темно-оранжевым цветом.

Относительные ссылки

Вы можете определить относительные ссылки и пути к изображениям в отображаемых файлах, чтобы читателям было проще переходить к другим файлам в репозитории.

Относительная ссылка — это ссылка, заданная относительно текущего файла. Например, если есть файл сведений в корне репозитория и еще один файл в docs/CONTRIBUTING.md, относительная ссылка на CONTRIBUTING.md в файле сведений может выглядеть следующим образом:

[Contribution guidelines for this project](docs/CONTRIBUTING.md)

GitHub автоматически преобразует относительную ссылку или путь к изображению с учетом текущей ветви, чтобы ссылка или путь всегда работали. Путь ссылки будет относительным к текущему файлу. Ссылки, начинающиеся с /, будут относительными к корневому каталогу репозитория. Можно использовать любые операнды относительных ссылок, например ./ и ../.

Относительные ссылки удобнее для пользователей, которые клонируют репозиторий. Абсолютные ссылки могут не работать в клонах репозитория. Мы рекомендуем использовать относительные ссылки на другие файлы в репозитории.

Изображения

Вы можете включить изображение, добавив ! и заключив замещающий текст в [ ]. Замещающий текст — это короткий текстовый эквивалент информации на изображении. Затем заключите ссылку на изображение в круглые скобки ().

![Screenshot of a comment on a GitHub issue showing an image, added in the Markdown, of an Octocat smiling and raising a tentacle.](https://myoctocat.com/assets/images/base-octocat.svg)

Снимок экрана: комментарий к проблеме GitHub с изображением, добавленным в Markdown, на котором octocat улыбается и поднимает щупальцо.

GitHub поддерживает внедрение изображений в проблемы, запросы на вытягивание, обсуждения, комментарии и файлы .md. Вы можете отобразить изображение из репозитория, добавить ссылку на изображение в Интернете или отправить изображение. Дополнительные сведения см. в разделе Отправка ресурсов.

Совет: Если вы хотите отобразить изображение, которое находится в репозитории, используйте относительные ссылки вместо абсолютных ссылок.

Ниже приведены некоторые примеры использования относительных ссылок для отображения изображений.

Контекст Относительная ссылка
В файле .md в той же ветви /assets/images/electrocat.png
В файле .md в другой ветви /../main/assets/images/electrocat.png
В проблемах, запросах на вытягивание и комментариях репозитория ../blob/main/assets/images/electrocat.png?raw=true
В файле .md в другом репозитории /../../../../github/docs/blob/main/assets/images/electrocat.png
В проблемах, запросах на вытягивание и комментариях другого репозитория ../../../github/docs/blob/main/assets/images/electrocat.png?raw=true

Примечание. Последние две относительные ссылки в приведенной выше таблице будут работать для изображений в частном репозитории только в том случае, если у средства просмотра есть по крайней мере доступ на чтение к частному репозиторию, который содержит эти образы.

Дополнительные сведения см. в разделе Относительные ссылки.

Указание темы, в которой отображается изображение

Вы можете указать тему, для которой отображается изображение, в Markdown с помощью HTML-элемента <picture> в сочетании с функцией мультимедиа prefers-color-scheme. Имеется два цветовых режима: светлый и темный, поэтому доступны два варианта. Эти варианты можно использовать для отображения изображений, оптимизированных для темных или светлых фонов. Особенно полезно это в случае с прозрачными изображениями в формате PNG.

Например, с помощью следующего кода отображается изображение солнца для светлых тем и луны для темных тем:

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/25423296/163456776-7f95b81a-f1ed-45f7-b7ab-8fa810d529fa.png">
  <source media="(prefers-color-scheme: light)" srcset="https://user-images.githubusercontent.com/25423296/163456779-a8556205-d0a5-45e2-ac17-42d089e3c3f8.png">
  <img alt="Shows an illustrated sun in light mode and a moon with stars in dark mode." src="https://user-images.githubusercontent.com/25423296/163456779-a8556205-d0a5-45e2-ac17-42d089e3c3f8.png">
</picture>

Старый метод указания изображений на основе темы с помощью фрагмента, добавленного к URL-адресу (#gh-dark-mode-only или #gh-light-mode-only), объявлен нерекомендуемым и будет заменен новым методом, который описан выше.

Списки

Вы можете создать неупорядоченный список, предваряя одну или несколько строк текста с -помощью , *или +.

- George Washington
* John Adams
+ Thomas Jefferson

Снимок экрана: отрисованный GitHub Markdown с маркированный список имен первых трех американских президентов.

Чтобы упорядочить список, поставьте перед каждой строкой номер.

1. James Madison
2. James Monroe
3. John Quincy Adams

Снимок экрана: отрисованный GitHub Markdown с нумерованным списком имен четвертого, пятого и шестого американских президентов.

Вложенные списки

Чтобы создать вложенный список, добавьте отступы для одного или нескольких элементов списка под другим элементом.

Чтобы создать вложенный список с помощью веб-редактора GitHub или текстового редактора, использующего однопространствовый шрифт, например Visual Studio Code, можно визуально выровнять список. Введите пробелы перед вложенным элементом списка, пока символ маркера списка (- или *) не будет расположен непосредственно под первым символом текста в элементе над ним.

1. First list item
   - First nested list item
     - Second nested list item

Примечание. В веб-редакторе можно добавить или убрать отступы для одной или нескольких строк текста, сначала выделив нужные строки, а затем нажав клавиши TAB или SHIFT+TAB соответственно.

Снимок экрана: Markdown в Visual Studio Code показывает, как маркеры с отступом выравниваются по вертикали с первой буквой строк текста над ними.

Снимок экрана: отображаемый элемент GitHub Markdown с нумерованным элементом, за которым следует маркированный элемент, вложенный на один уровень справа, а другой маркированный элемент, вложенный еще дальше справа.

Чтобы создать вложенный список в редакторе комментариев на GitHub, в котором не используется моноширинный шрифт, можно подсчитать количество символов перед содержимым элемента списка непосредственно над вложенным списком. Затем введите такое же число пробелов перед элементом вложенного списка.

В этом примере можно добавить элемент вложенного списка под элементом 100. First list item списка, отступив от начала строки не менее чем на пять пробелов, так как перед текстом First list item пять символов (100. ).

1.   First list item
     - First nested list item

Снимок экрана: отображаемый элемент GitHub Markdown с элементом списка, предваряемым числом 100, за которым следует маркированный элемент, вложенный на один уровень справа.

Таким же образом можно создавать несколько уровней вложения списков. Например, так как в элементе первого вложенного списка перед содержимым First nested list item семь символов (␣␣␣␣␣-␣), в строке элемента второго вложенного списка необходимо отступить от начала на семь пробелов.

1.   First list item
     - First nested list item
       - Second nested list item

Снимок экрана: отображаемый элемент GitHub Markdown с элементом списка, предваряемым числом 100, за которым следует маркированный элемент, вложенный на один уровень справа, а другой маркированный элемент, вложенный еще дальше справа.

Дополнительные примеры см. в спецификации GitHub Flavored Markdown.

Списки задач

Чтобы создать список задач, добавьте к элементам списка префикс — дефис, пробел, а затем [ ]. Чтобы пометить задачу как завершенную, используйте [x].

- [x] #739
- [ ] https://github.com/octo-org/octo-repo/issues/740
- [ ] Add delight to the experience when all tasks are complete :tada:

Отрисованный список задач

Если описание элемента списка задач начинается с круглой скобки, необходимо экранировать ее с помощью символа :

- [ ] (Optional) Open a followup issue

Дополнительные сведения см. в разделе Сведения о списках задач.

Упоминание людей и команд

Вы можете упомянуть пользователя или команду на GitHub, введя @ перед их именем. Пользователь или команда получит уведомление, которое привлечет их внимание к беседе. Пользователи также получают уведомления, когда вы изменяете комментарий, упоминая имя пользователя или команды. Дополнительные сведения об уведомлениях см. в разделе Об уведомлениях.

Примечание. Пользователь будет получать уведомления об упоминании, только если он имеет доступ на чтение к репозиторию и, если репозиторий принадлежит организации, пользователь является членом организации.

@github/support What do you think about these updates?

Снимок экрана: отображаемый GitHub Markdown, показывающий, как команда упоминает "@github/support", отображается как полужирный, щелкаемый текст.

Когда вы упоминаете родительскую команду, члены дочерних команд также получают уведомления, что упрощает взаимодействие с несколькими группами людей. Дополнительные сведения см. в разделе Сведения о командах.

При вводе символа @ отображается список людей или команд, участвующих в проекте. Список фильтруется по мере ввода, поэтому после того, как вы найдете имя нужного человека или команды, можно выбрать его с помощью клавиш со стрелками и нажать клавишу TAB или ВВОД, чтобы завершить имя. Для команд введите @organization/team-name, и все члены этой команды будут подписаны на беседу.

Результаты автозавершения ограничены участниками репозитория и любыми другими участниками беседы.

Ссылка на проблемы и запросы на вытягивание

Вы можете получить список предлагаемых проблем и запросов на вытягивание в репозитории, введя #. Введите номер или заголовок проблемы либо запроса на вытягивание, чтобы отфильтровать список, а затем нажмите клавишу TAB или ВВОД, чтобы завершить выделенный результат.

Дополнительные сведения см. в разделе Автосвязанные ссылки и URL-адреса.

Ссылка на внешние ресурсы

Если для репозитория настроены пользовательские автоматические ссылки, то ссылки на внешние ресурсы, такие как проблема JIRA или тикет Zendesk, конвертируются в сокращенные ссылки. Чтобы узнать, какие автоматические ссылки доступны в репозитории, обратитесь к кому-то, у кого есть разрешения администратора в отношении репозитория. Дополнительные сведения см. в разделе Настройка автоматической привязки для отсылок на внешние ресурсы.

Отправка ресурсов

Вы можете отправлять такие ресурсы, как изображения, путем перетаскивания, выбора в обозревателе файлов или вставки. Вы можете отправлять ресурсы в проблемы, запросы на вытягивание, комментарии и файлы .md в репозитории.

Использование эмодзи

Вы можете добавить эмодзи в текст, введя :EMOJICODE:двоеточие и имя эмодзи.

@octocat :+1: This PR looks great - it's ready to merge! :shipit:

Снимок экрана: отрисованный GitHub Markdown, показывающий, как коды эмодзи для +1 и shipit визуализируются как эмодзи.

При вводе : отображается список предлагаемых эмодзи. Список фильтруется по мере ввода, поэтому после того, как вы найдете нужный эмодзи, нажмите клавишу TAB или ВВОД, чтобы завершить выделенный результат.

Полный список доступных эмодзи и кодов см. в разделе Эмодзи-Памятка.

Абзацы

Чтобы создать абзац, оставьте пустую строку между строками текста.

Вы можете добавлять в содержимое сноски с помощью квадратных скобок, используя следующий синтаксис:

Here is a simple footnote[^1].

A footnote can also have multiple lines[^2].

[^1]: My reference.
[^2]: To add line breaks within a footnote, prefix new lines with 2 spaces.
  This is a second line.

Сноски отрисовываются следующим образом:

Снимок экрана: отображаемый markdown с надстрочных чисел, используемых для обозначения сносок, а также необязательные разрывы строк внутри заметки.

Примечание. Позиция сноски в Markdown не влияет на то, где сноска будет отрисовываться. Вы можете написать текст сноски сразу после ссылки на нее, и сноска по-прежнему будет отображаться в нижней части документа Markdown.

Сноски на вики-сайтах не поддерживаются.

Скрытие содержимого с помощью комментариев

Вы можете сообщить GitHub, что необходимо скрыть содержимое в отрисованном файле Markdown, поместив это содержимое в комментарий HTML.

<!-- This content will not appear in the rendered Markdown -->

Игнорирование форматирования Markdown

Вы можете сообщить GitHub, что необходимо игнорировать (или экранировать) форматирование Markdown, используя символ перед символом Markdown.

Let's rename *our-new-project* to *our-old-project*.

Снимок экрана: отрисованный GitHub Markdown, показывающий, как обратные косые знаки препятствуют преобразованию звездочек в курсив. Текст гласил: "Давайте переименуем наш новый-проект в наш-старый проект".

Дополнительные сведения о обратных косых чертах см. в разделе Синтаксис Markdown в Daring Fireball.

Отключение отрисовки Markdown

При просмотре файла Markdown можно щелкнуть в верхней части файла, чтобы отключить обработку файлов Markdown и просмотреть источник файла.

Снимок экрана: файл Markdown в репозитории GitHub с параметрами взаимодействия с файлом. Кнопка для отображения исходного BLOB-объекта выделена темно-оранжевым цветом.

Отключение обработки файлов Markdown позволяет использовать функции просмотра источника, такие как связывание строк, что невозможно при просмотре обработанных файлов Markdown.

Дополнительные материалы

  • Спецификация GitHub Flavored Markdown
  • «Сведения о написании и форматировании текста на GitHub»
  • «Работа с расширенным форматированием»
  • «Краткое руководство по написанию на GitHub»

Иногда не только сама документация, но и процесс работы над ней может быть критичным. Например, в случае проектов львиная часть работы связана именно с подготовкой документации, и неправильный процесс может привести к ошибкам и даже к потере информации, а, следовательно, и к потере времени и выгоды. Но даже если эта тема и не является центральной в вашей работе и находится на периферии, то все равно правильный процесс может улучшить качество документа и сэкономить вам время.

Изложенный здесь подход, с примером конкретной реализации, имеет низкий порог вхождения. Технически, уже завтра вы можете начать работать по-новому.

Постановка задачи

Вам нужно создать некий документ или набор документов. Возможно, это проектная документация или протоколирование вашей сети, или что-то более простое, например, вы должны описать процессы в компании или в вашем отделе. В общем, речь идет о любом документе или наборе документов с текстом, картинками, табличками… Усложним задачу тем, что

  1. данная работа предполагает совместный труд, усилия группы или нескольких групп сотрудников
  2. на выходе вы хотите иметь документ в определенном формате, с атрибутами корпоративного стиля, созданный по определенному шаблону. Для определенности мы будем считать, что это MS Word (.docx)

10 лет назад подход был бы однозначным: мы бы создали MS Word документ или документы и каким-либо образом организовали бы работу по изменению.

И такой подход по-прежнему в силе. Им пользуются в том числе и крупные интеграторы при создании проектной документации. Но интуитивно понятно, что, если вы действительно интенсивно, со многими правками и обсуждениями, в течении продолжительного времени работаете над документом данный подход не очень удобен.

Пример

Я довольно остро ощутил эту проблему, работая в одном крупном интеграторе. Процесс изменения проектной документации был следующий:

  1. инженер скачивает последнюю версию MS Word (.docx) документа
  2. меняет название
  3. вносит правки в track моде
  4. отсылает документ с правками архитектору
  5. так же отсылает перечень всех исправлений с комментариями
  6. архитектор анализирует изменения
  7. если все хорошо, то копирует данные изменения в файл с последней версией, меняет версию, выкладывает на общий ресурс
  8. если есть замечания, то инициируется обсуждение (email или митинги)
  9. достигается консенсус
  10. далее пункты 3 — 9

Пока работа не была интенсивной, то это кое-как, но все же работало. Но в определенный момент этот процесс стал узким местом целого проекта и привел к проблемам. Дело в том, что все становится плохо, как только изменения производятся часто и одновременно несколькими командами.

Так, когда мы перешли на стадию предварительного тестирования, то начали проявляться разные проблемки и, хотя и по мелочам, но нужно было часто менять документацию — четыре разные команды, ежедневно, практически одновременно, с обсуждениями. Все эти изменения проходили через одного инженера — архитектора. Файл с дизайном проекта был огромный, и как следствие, архитектор был завален рутинной работой, связанной с большим количеством копирования, редактирования, делал много ошибок, приходилось все перепроверять, перепосылать, и в общем это было близко к хаосу.

В данном случае этот подход, подход работы над документом MS Word, работал с большим скрипом и создавал проблемы.

Git, Markdown

Столкнувшись с проблемой, описанной в примере выше, я стал исследовать этот вопрос.
Я увидел, что все более становится популярным использование Markdown совместно с Git при создании документов.

Git — это инструмент для разработки. Но почему бы его не использовать для процесса документирования? В этом случае вопрос многопользовательской работы становится решенным. Но для того, чтобы в полной мере использовать возможности Git нам нужен текстовый формат документа, нам нужно найти другой инструмент, не MS Word, и для этих целей отлично подходит Markdown.

Markdown — простой язык текстовой разметки. Он предназначен для создания красиво оформленных текстов в обычных файлах формата TXT. Если мы будем создавать наши документы в Markdown, то связка Markdown — Git выглядит естественной.

И все бы хорошо, и в этом месте можно было бы поставить точку, если бы не наше второе условие: «на выходе нам нужен документ в определенном формате, с атрибутами корпоративного стиля, созданный по определенному шаблону» (и мы договорились вначале, что для определенности это будет MS Word). То есть, если мы решили использовать Markdown, то нам нужно как-то преобразовать этот файл в .docx требуемого вида.

Существуют программы конвертации между различными форматами, например, Pandoc.
Вы можете конвертировать Markdown файл в .docx формат с этой программой.
Но все же, надо понимать, что, во-первых, не все, что есть в Markdown будет конвертировано в MS Word и, во-вторых, MS Word — это целая страна по сравнению со стройным, но все же городком, Markdown. Есть огромное количество всего, что есть в Word и ни в каком виде нет в Markdown. Нельзя просто так вот взять и с определенными ключами Pandoc конвертировать ваш Markdown формат в желанный вид MS Word. Так что обычно, после конвертации, приходится «дорабатывать» полученный .docx документ вручную, что опять-таки может быть затратным с точки зрения времени и приводить к ошибкам.

Если бы мы могли написать скрипт, который автоматически «доделывал» бы то, с чем не справился Pandoc — это было бы идеальное решение.

В силу не тождественности функционала MS Word и Markdown в общем виде решить эту задачу, думаю, невозможно, но можно ли это сделать применительно к конкретным ситуациям, конкретным требованиям? Мой опыт показал, что да, можно и скорее всего это возможно для многих, или может быть даже большинства ситуаций.

Решение частной задачи

Так, в моем случае, после конвертации файла с помощью Pandoc, мне приходилось вручную делать дополнительную обработку файлов, а именно

  • добавлять в Word поля с автоматической нумерацией заголовков (caption) таблиц и картинок
  • менять стиль для таблиц

Я не нашел, как это сделать стандартными (Pandoc) или известными средствами. Поэтому я применил python скрипт с pywin32 пакетом. В результате я получил полную автоматизацию. Теперь я могу конвертировать мой Markdown файл в нужную форму MS Word документа одной командой.

Смотрите детали здесь.

Замечание

В этом примере я, конечно же, преобразую некий абстрактный Markdown файл, но в точности тот же подход был применен к «боевому» документу, и на выходе я получил практически точно тот же MS Word документ, который до этого мы получали ручным форматированием.

В общем, c pywin32 мы получаем практически полный контроль над MS Word документом, что позволяет менять его, и приводить к виду, который требует ваш корпоративный стандарт. Конечно, этих же целей можно было добиться и с использование других инструментов, например, VBA макросов, но мне было удобней использовать python.

Краткая формула данного подхода:

Markdown + Git -- (нечто) --> MS Word

Не так важно, чем является «нечто». В моем случае это был Pandoc и python с pywin32. Возможно, у вас другие предпочтения, но важно то, что это возможно. И это и есть главный посыл этой статьи.

Резюмируя, идея в том, что при таком подходе вы работаете только с Markdown файлом и пользуетесь Git для организации совместной работы и для контроля версий, и только при необходимости (например, чтобы предоставить документацию клиенту) автоматически создаете файл нужного формата (например, MS Word).

Процесс

Думаю, для многих формула, приведенная выше достаточна, чтобы понять, как теперь может быть организован процесс работы с документацией. Но все же я обычно ориентируюсь на сетевых инженеров, поэтому в общих чертах покажу, как теперь может выглядеть процесс работы, и чем это отличается от подхода с редактированием MS Word файлов.

Для определенности, в качестве платформы для работы с Git выберем GitHub. Тогда вы должны создать репозиторий и в master ветке поместить Markdown файл или файлы, с которыми планируете работать.

Мы рассмотрим простой процесс, основанный на «github flow». Его описание можно найти, как в интернете, так и на хабре.

Предположим, что над документацией работают четыре человека и вы — один из них. Тогда создаются четыре дополнительные ветки (branch), например, с именами этих людей. Каждый работает локально, в своей ветке и делает изменения со всеми необходимыми git командами.

Выполнив какой-то законченный кусок работы, вы формируете pull request, инициируя таким образом обсуждение ваших изменений. Возможно, в процессе обсуждения, выяснится, что вы должны добавить или изменить что-то еще. В этом случае, вы делаете необходимые изменения и создаете дополнительный pull request. В конце концов, ваши изменения принимаются и сливаются (merge) с master веткой (или отвергаются).

Конечно, это довольно общее описание. Предлагаю для создания детализированного процесса обратиться к вашим разработчикам или найти знающих людей. Но хочу заметить, что порог вхождения в Git довольно низкий. Это не говорит о том, что протокол простой, но вы можете начать с простого. Если вы совсем ничего не знаете, думаю, потратив несколько часов или может быть дней на изучение и установку, вы можете начать им пользоваться.

Какая же польза в данном подходе по сравнению, например, с процессом, описанном в примере выше?

На самом деле процессы довольно схожи, просто вы заменили

копирование файла -> создание ветки (branch)
копирование текста в конечный файл-> слияние (merge)
копирование последних изменений к себе -> git pull/fetch
обсуждение в переписке -> pull requests
track mode -> git diff
последняя утвержденная версия -> master ветка
бэкап (копирование на удаленный сервер) -> git push

Таким образом вы автоматизировали все то, что вам и так приходилось делать, но вручную.

На более высоком уровне это позволяет вам

  • создать ясный, простой и контролируемый процесс изменений документации
  • т.к. конечный документ (в нашем примере MS Word) вы создаете автоматически, то это уменьшает вероятность ошибок, связанных с форматированием

Замечание

В силу сказанного выше, думаю очевидно, что, даже если вы работаете над документацией один, то использование Git может существенно облегчить вашу работу

Все это повышает качество документации и уменьшает время на ее создание. И еще небольшой бонус — вы изучите Git, что поможет вам при автоматизации вашей сети :)

Как перейти на новый процесс?

В начале статьи я написал, что уже завтра вы можете начать работать по-новому. Как перевести вашу работу в новое русло?

Вот последовательность шагов, которую вам скорее всего придется выполнить:

  • если ваш документ очень большой, разбейте его на части
  • конвертируйте каждую часть в Markdown (с помощью Pandoc, например)
  • установите один из редакторов Markdown (я пользуюсь Typora)
  • скорее всего вам придется подправить форматирование созданных Markdown документов
  • начинайте применять процесс, описанный в предыдущей главе
  • параллельно начинайте видоизменять скрипт конвертации под свою задачу (или создайте что-то свое)

Вам не обязательно ждать, когда вы создадите и отладите в совершенстве механизм конвертации Markdwon -> требуемый на выходе вид документа. Дело в том, что, даже если вам не удастся быстро полностью автоматизировать процедуру преобразования ваших Markdown файлов, вы все равно сможете это сделать в каком-либо виде с помощью Pandoc и далее довести до конечного вида вручную. Обычно вам не нужно это делать часто, а только в конце определенных этапов, и эта ручная работа, хоть и неудобна, но все же, на мой взгляд, вполне допустима на этапе отладки и не должна сильно «тормозить» процесс.

Все остальное (Markdown, Git, Pandoc, Typora) уже готово и не требует особых усилий или времени для того, чтобы начать работать с ними.

Getting started with writing and formatting on Github

You can use simple features to format your comments and interact with others in issues, pull requests, and wikis on GitHub.

About writing and formatting on Github

GitHub combines a syntax for formatting text called GitHub Flavored Markdown with a few unique writing features.

Markdown is an easy-to-read, easy-to-write syntax for formatting plain text.

We’ve added some custom functionality to create GitHub Flavored Markdown, used to format prose and code across our site.

You can also interact with other users in pull requests, issues, and wikis with features like @mentions, issue and PR references, and emoji.

Text formatting toobar

Every comment field on GitHub contains a text formatting toolbar, allowing you to format your text without learning Markdown syntax. In addition to Markdown formatting like bold and italic styles and creating headers, links, and lists, the toolbar includes GitHub-specific features such as @mentions, task lists, and links to issues and pull requests.

Markdown toolbar

Further reading

  • “Basic writing and formatting syntax”
  • “Working with advanced formatting”
  • “Mastering Markdown”
  • “Markdown Tutorial”

Basic writing and formatting syntax

Create sophisticated formatting for your prose and code on GitHub with simple syntax.

Headings

To create a heading, add one to six # symbols before your heading text. The number of # you use will determine the size of the heading.

# The largest heading
## The second largest heading
###### The smallest heading

Rendered H1, H2, and H6 headings

Styling text

You can indicate emphasis with bold, italic, or strikethrough text.

Style Syntax Keyboard shortcut Example Output
Bold ** ** or __ __ command/control + b **This is bold text** This is bold text
Italic * * or _ _ command/control + i *This text is italicized* This text is italicized
Strikethrough ~~ ~~   ~~This was mistaken text~~ This was mistaken text
Bold and italic ** ** and _ _   **This text is _extremely_ important** This text is extremely important

Quoting text

You can quote text with a >.

In the words of Abraham Lincoln:
> Pardon my French

Rendered quoted text

Quoting code

You can call out code or a command within a sentence with single backticks. The text within the backticks will not be formatted.

Use `git status` to list all new or modified files that haven't yet been committed.

Rendered inline code block

To format code or text into its own distinct block, use triple backticks.

	Some basic Git commands are:
	```
	git status
	git add
	git commit
	```

Rendered code block

For more information, see “Creating and highlighting code blocks.”

Links

You can create an inline link by wrapping link text in brackets [ ], and then wrapping the URL in parentheses ( ). You can also use the keyboard shortcut command + k to create a link.

This site was built using [GitHub Pages](https://pages.github.com/).

Rendered link

Lists

You can make a list by preceding one or more lines of text with - or *.

- George Washington
- John Adams
- Thomas Jefferson

Rendered unordered list

To order your list, precede each line with a number.

1. James Madison
2. James Monroe
3. John Quincy Adams

Rendered ordered list

You can create nested lists by indenting lines by two spaces.

1. Make my changes
  1. Fix bug
  2. Improve formatting
    * Make the headings bigger
2. Push my commits to GitHub
3. Open a pull request
  * Describe my changes
  * Mention all the members of my team
    * Ask for feedback

Rendered nested list

Task lists

You can create task lists by prefacing list items with [ ]. To mark a task as complete, use [x].

Task lists render with checkboxes in all comments and Markdown files. Select or unselect the checkboxes to mark them as complete or incomplete.

- [x] Finish my changes
- [ ] Push my commits to GitHub
- [ ] Open a pull request

Rendered task list

You can reorder task lists by clicking to the left of a task’s checkbox, dragging it to a new location, and dropping it. If you have multiple lists within a comment, you can reorder tasks across them. You can’t add or reorder tasks in other comments.

Reordered task list

Mentioning users and teams

You can mention a user or team on GitHub by typing @ plus their username or team name to bring their attention to an issue or pull request.

@github/support What do you think about these updates?

Rendered @mention

Typing an @ symbol will bring up a list of people or teams on a project. The list filters as you type, so once you find the name of the person or team you are looking for, you can use the arrow keys to select it and hit either tab or enter to complete the name. For teams, just enter the @organization/team-name and all members of that team will get subscribed to the issue.

The autocomplete results are restricted to repository collaborators and any other participants on the thread.

Referencing issues and pull requests

You can bring up a list of suggested Issues and Pull Requests within the repository by typing #. Type the issue or PR number or title to filter the list, then hit either tab or enter to complete the highlighted result.

For more information, see “Autolinked references and URLs.”

Using emoji

You can add emoji to your writing by typing :EMOJICODE:.

@octocat :+1: This PR looks great - it's ready to merge! :shipit:

Rendered emoji

Typing : will bring up a list of suggested emoji. The list will filter as you type, so once you find the emoji you’re looking for, press Tab or Enter to complete the highlighted result.

For a full list of available emoji and codes, check out emoji-cheat-sheet.com.

Paragraphs and line breaks

You can create a new paragraph by leaving a blank line between lines of text.

Ignoring Markdown formatting

You can tell GitHub to ignore (or escape) Markdown formatting by using before the Markdown character.

Let's rename *our-new-project* to *our-old-project*.

Rendered escaped character

Further reading

  • “About writing and formatting on GitHub”
  • “Working with advanced formatting”
  • “Mastering Markdown”
  • “Markdown Tutorial”

Working with advanced formatting

Formatting like tables, syntax highlighting, and automatic linking allows you to arrange complex information clearly in your pull requests, issues, and comments.

Organizing information with tables

You can build tables to organize information in comments, issues, pull requests, and wikis.

Creating a table

You can create tables with pipes | and hyphens -. Hyphens are used to create each column’s header, while pipes separate each column.

| First Header  | Second Header |
| ------------- | ------------- |
| Content Cell  | Content Cell  |
| Content Cell  | Content Cell  |

Rendered table

The pipes on either end of the table are optional.

Cells can vary in width and do not need to be perfectly aligned within columns. There must be at least three hyphens in each column of the header row.

| Command | Description |
| --- | --- |
| git status | List all new or modified files |
| git diff | Show file differences that haven't been staged |

Rendered table with varied cell width

Formatting content within your table

You can use formatting such as links, inline code blocks, and text styling within your table:

| Command | Description |
| --- | --- |
| `git status` | List all *new or modified* files |
| `git diff` | Show file differences that **haven't been** staged |

Rendered table with formatted text

You can align text to the left, right, or center of a column by including colons : to the left, right, or on both sides of the hyphens within the header row.

| Left-aligned | Center-aligned | Right-aligned |
| :---         |     :---:      |          ---: |
| git status   | git status     | git status    |
| git diff     | git diff       | git diff      |

Rendered table with left, center, and right text alignment

To include a pipe | as content within your cell, use a before the pipe:

| Name     | Character |
| ---      | ---       |
| Backtick | `         |
| Pipe     | |        |

Rendered table with an escaped pipe

Further reading

  • “Basic writing and formatting syntax”

Creating and highlighting code blocks

Share samples of code with fenced code blocks and enabling syntax highlighting.

Fenced code blocks

You can create fenced code blocks by placing triple backticks «« before and after the code block. We recommend placing a blank line before and after code blocks to make the raw formatting easier to read.

	```
	function test() {
	  console.log("notice the blank line before this function?");
	}
	```

Rendered fenced code block

Syntax highlighting

You can add an optional language identifier to enable syntax highlighting in your fenced code block.

For example, to syntax highlight Ruby code:

	```ruby
	require 'redcarpet'
	markdown = Redcarpet.new("Hello World!")
	puts markdown.to_html
	```

Rendered code block with Ruby syntax highlighting

We use Linguist to perform language detection and syntax highlighting. You can find out which keywords are valid in the languages YAML file.

Further reading

  • “Basic writing and formatting syntax”

Autolinked references URLs

References to URLs, issues, pull requests, and commits are automatically shortened and converted into links.

URLs

GitHub automatically creates links from standard URLs.

For more information on creating links, see “Basic writing and formatting syntax.”

Issues and pull requests

Within repositories, references to issues and pull requests are automatically converted to shortened links to the issue or pull request.

Reference type Raw reference Short link  
Issue or pull request URL https://github.com/jlord/sheetsee.js/issues/26 #26  
#and issue or pull request number #26 #26  
GH-and issue or pull request number   #26 #26
Username#and issue or pull request number   jlord#26 jlord#26
Username/Repositoryand issue or pull request number   jlord/sheetsee.js#26 jlord/sheetsee.js#26

Commit SHAs

References to a commit’s SHA hash are automatically converted into shortened links to the commit on GitHub.

To save time and make sure you’re delivering a consistent message, you can add saved replies to issue and pull request comments.

Once you’ve added a saved reply, it can be used in both issues and pull requests. Saved replies are tied to your user account. Once they’re created, you’ll be able to use them across repositories and organizations.

Creating a saved reply

If you frequently add the same comment over and over, you can create a saved reply.

Changing a saved reply

If you have a saved reply that has an error or isn’t saying exactly what you’d like, you can make it more useful by changing it.

Deleting a saved reply

If you find that you’re no longer using a saved reply, you can delete it.

When commenting on an issue or pull request, you can add a saved reply that you’ve already set up. The saved reply can be the entire comment or if you want to customize it, you can add or delete content.

View the original page: https://help.github.com/categories/writing-on-github/

26 октября, 2019 12:22 пп
1 907 views
| Комментариев нет

Cloud Server, Linux

Контроль версий полезен не только в разработке кода – с его помощью вы сможете отслеживать версии любого контента. Например, с помощью Git вы можете управлять своими текстовыми работами: это дает возможность просматривать несколько черновиков одновременно, оценивать различия между ними и даже откатываться к предыдущей версии. При необходимости вы можете поделиться своей работой с другими пользователями на GitHub или в других репозиториях Git.

В этом мануале мы покажем, как использовать Git для управления небольшим документом Markdown. Вы научитесь сохранять исходные версии, отправлять коммиты, вносить изменения, просматривать разницу между версиями и возвращаться к предыдущей версии. Такой рабочий процесс вы сможете применить к своим проектам.

Требования

Базовая установка Git на локальном компьютере. Мануал Разработка проектов с открытым исходным кодом: начало работы с Git поможет вам установить Git и предоставит дополнительную информацию.

1: Создание рабочего пространства для проекта

Чтобы управлять изменениями в тексте, нужно создать локальный репозиторий Git. Git-репозиторий должен находиться внутри существующего каталога, поэтому сначала мы создадим отдельный каталог для вашего текста (предположим, вы пишете статью):

mkdir article

Перейдите в каталог article:

cd article

С помощью команды git init создайте в текущем каталоге новый пустой репозиторий Git:

git init

Вы увидите такой вывод, если все пройдет успешно:

Initialized empty Git repository in /Users/8host/article/.git/

Файл .gitignore позволяет задать файлы, которые Git следует игнорировать. Вы можете использовать этот файл, чтобы игнорировать временные файлы, которые создает текстовый редактор, или файлы операционной системы. Например, в macOS приложение Finder создает в каталогах файлы .DS_Store. Создайте файл .gitignore, который будет их игнорировать:

nano .gitignore

Добавьте следующие строки в этот файл:

# Ignore Finder files
.DS_store

Первая строка – это комментарий, который в будущем поможет вам определить, какие файлы нужно игнорировать. Вторая строка указывает сам файл.

Сохраните файл и выйдите из редактора.

Если вам нужно игнорировать больше файлов, просто откройте файл .gitignore и добавьте новую строку для каждого файла или каталога.

Теперь репозиторий настроен, и вы можете начать работу с текстом.

2: Сохранение черновика

Git знает только о тех файлах, о которых вы ему рассказали. То есть тот факт, что в каталоге, где находится репозиторий, существует файл, не означает, что Git будет отслеживать его изменения. Вы должны добавить файл в репозиторий и затем отправить коммит об изменениях.

Создайте новый файл Markdown article.md:

nano article.md

Добавьте в него такой текст:

# How To Use Git to Manage Your Writing Project
### Introduction
Version control isn't just for code. It's for anything you want to track, including content. Using Git to manage your next writing project gives you the ability to view multiple drafts at the same time,  see differences between those drafts, and even roll back to a previous version. And if you're comfortable doing so, you can then share your work with others on GitHub or other central git repositories.
In this tutorial you'll use Git to manage a small Markdown document. You'll store an initial version, commit it, make changes, view the difference between those changes, and review the previous version. When you're done, you'll have a workflow you can apply to your own writing projects.

Сохраните и закройте файл.

Команда git status покажет вам состояние вашего репозитория. С ее помощью можно узнать, какие файлы нужно добавить, чтобы Git мог их отслеживать. Запустите эту команду:

git status

Вы увидите такой вывод:

On branch master
No commits yet
Untracked files:
(use "git add <file>..." to include in what will be committed)
.gitignore
article.md
nothing added to commit but untracked files present (use "git add" to track)

В выводе секция Untracked files показывает файлы, которые Git не отслеживает. Эти файлы необходимо добавить в репозиторий, чтобы Git мог следить за изменениями в них. Используйте команду git add, чтобы сделать это:

git add .gitignore
git add article.md

Теперь запустите git status, чтобы убедиться, что эти файлы отслеживаются:

On branch master
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file:   .gitignore
new file:   article.md

Оба файла теперь перечислены в разделе Changes to be committed. Git знает о них, но пока еще не создал снапшот. Для этого используется git commit.

Когда вы создаете новый коммит, вы должны предоставить сообщение о коммите. В таком сообщении указываются все изменения. Когда вы работаете над текстом с другими людьми, пишите подробные сообщения о коммитах – это сделает вашу работу эффективнее.

Используйте команду git commit для фиксации ваших изменений:

git commit -m "Add gitignore file and initial version of article"

Вывод команды показывает, что изменения зафиксированы:

[master (root-commit) 95fed84] Add gitignore file and initial version of article
2 files changed, 9 insertions(+)
create mode 100644 .gitignore
create mode 100644 article.md

Используйте команду git status, чтобы уточнить состояние репозитория:

git status

Вывод команды покажет, что никаких изменений, которые нужно добавить или зафиксировать, на данный момент нет.

On branch master
nothing to commit, working tree clean

3: Сохранение ревизии

Итак, вы добавили исходную версию статьи. Теперь пора добавить больше текста – вы увидите, как управлять изменениями с помощью Git.

Откройте статью в текстовом редакторе:

nano article.md

Добавьте новый текст в конец файла:

* Git installed on your local computer. The tutorial (https://www.8host.com/blog/razrabotka-proektov-s-otkrytym-isxodnym-kodom-nachalo-raboty-s-git/) walks you through installing Git and covers some background information you may find useful.

Используйте команду git status, чтобы узнать состояние вашего репозитория:

git status

Вы получите вывод:

On branch master
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
modified:   article.md
no changes added to commit (use "git add" and/or "git commit -a")

Как и ожидалось, файл article.md изменился. С помощью git diff вы можете увидеть эти изменения:

git diff article.md

Вы получите такой вывод:

diff --git a/article.md b/article.md
index 77b081c..ef6c301 100644
--- a/article.md
+++ b/article.md
@@ -5,3 +5,7 @@
Version control isn't just for code. It's for anything you want to track, including content. Using Git to manage your next writing project gives you the ability to view multiple drafts at the same time,  see differences between those drafts, and even roll back to a previous version. And if you're comfortable doing so, you can then share your work with others on GitHub or other central git repositories.
In this tutorial you'll use Git to manage a small Markdown document. You'll store an initial version, commit it, make changes, view the difference between those changes, and review the previous version. When you're done, you'll have a workflow you can apply to your own writing projects.
+
+## Prerequisites
+
+* Git installed on your local computer. The tutorial (https://www.8host.com/blog/razrabotka-proektov-s-otkrytym-isxodnym-kodom-nachalo-raboty-s-git/) walks you through installing Git and covers some background information you may find useful.

В выводе есть строки, начинающиеся со знака плюс (+). Это добавленные вами строки. Удаленные строки будут отображаться со знаком минус (-). Строки, которые остались без изменений, будут без каких-либо символов.

Команды git diff и git status позволяют вам узнать, что вы изменили в тексте. Вы также можете сохранить разницу в файл, чтобы просмотреть его позже. Это делается с помощью следующей команды:

git diff article.md > article_diff.diff

Расширение .diff позволит текстовому редактору применить правильную подсветку синтаксиса.

Сохранение изменений в репозитории состоит из двух этапов. Сначала нужно добавить файл article.md еще раз, а затем отправить коммит. Git хочет, чтобы вы явно указывали, какие файлы входят в каждый коммит, поэтому, даже если вы добавили файл ранее, вам придется добавить его снова. Обратите внимание, что вывод команды git status напомнит вам об этом.

Добавьте файл и отправьте коммит с изменениями:

git add article.md
git commit -m "add prerequisites section"

Вы получите:

[master 1fbfc21] add prerequisites section
1 file changed, 4 insertions(+)

Используйте git status, чтобы узнать состояние вашего репозитория. Вы увидите, что делать больше ничего не нужно.

git status
On branch master
nothing to commit, working tree clean

Повторяйте этот процесс, пока будете просматривать свою статью. Внеся изменения, проверьте их, добавьте файл и отправьте коммит. Вносить изменения можно так часто, как вам удобно. Вы можете сделать коммит после того, как просмотрите весь черновик, или прямо перед тем, как внести серьезные изменения в структуру статьи.

Если вы отправляете черновик документа кому-то другому и он вносит в него изменения, возьмите новую копию и замените ею ваш файл. Затем используйте git diff, чтобы увидеть внесенные изменения. Git увидит изменения независимо от их источника: вы можете вносить изменения вручную или скачать файл из интернета или со своей почты.

Теперь давайте рассмотрим управление версиями текста.

4: Управление версиями и изменениями

Иногда бывает полезно взглянуть на предыдущую версию документа. Всякий раз, когда вы использовали git commit, вы отправляли полезное сообщение о коммите, в котором резюмировали все, что вы сделали.

Команда git log показывает историю изменений вашего репозитория. Каждое внесенное вами изменение имеет запись в журнале.

git log
commit 1fbfc2173f3cec0741e0a6b21803fbd0be511bc4
Author: 8host Blog <8host@blog>
Date:   Thu Sep 19 16:35:41 2019 -0500
add prerequisites section
commit 95fed849b0205c49eda994fff91ec03642d59c79
Author: 8host Blog <8host@blog>
Date:   Thu Sep 19 16:32:34 2019 -0500
Add gitignore file and initial version of article

Каждый коммит имеет определенный идентификатор. Этот номер используется для ссылки на данный коммит. Для ссылки вам нужны только первые несколько символов идентификатора. Команда git log –oneline выдает сокращенную версию лога с более короткими идентификаторами:

git log --oneline
1fbfc21 add prerequisites section
95fed84 Add gitignore file and initial version of article

Чтобы просмотреть исходную версию файла, используйте git show и идентификатор коммита. Идентификаторы в вашем репозитории будут отличаться от идентификаторов в наших примерах.

git show 95fed84 article.md

Выходные данные показывают детали коммита, а также изменения, которые внес этот коммит:

commit 95fed849b0205c49eda994fff91ec03642d59c79
Author: 8host Blog <8host@blog>
Date:   Thu Sep 19 16:32:34 2019 -0500
Add gitignore file and initial version of article
diff --git a/article.md b/article.md
new file mode 100644
index 0000000..77b081c
--- /dev/null
+++ b/article.md
@@ -0,0 +1,7 @@
+# How To Use Git to Manage Your Writing Project
+
+### Introduction
+
+Version control isn't just for code. It's for anything you want to track, including content. Using Git to manage your next writing project gives you the ability to view multiple drafts at the same time,  see differences between those drafts, and even roll back to a previous version. And if you're comfortable doing so, you can then share your work with others on GitHub or other central git repositories.
+
+In this tutorial you'll use Git to manage a small Markdown document. You'll store an initial version, commit it, make changes, view the difference between those changes, and review the previous version. When you're done, you'll have a workflow you can apply to your own writing projects.

Чтобы увидеть сам файл, слегка измените команду. Вместо пробела между идентификатором коммита и файлом вставьте символы :./. Вот так:

git show 95fed84:./article.md

Вы увидите содержимое этого файла в заданной редакции:

# How To Use Git to Manage Your Writing Project
### Introduction
Version control isn't just for code. It's for anything you want to track, including content. Using Git to manage your next writing project gives you the ability to view multiple drafts at the same time,  see differences between those drafts, and even roll back to a previous version. And if you're comfortable doing so, you can then share your work with others on GitHub or other central git repositories.
In this tutorial you'll use Git to manage a small Markdown document. You'll store an initial version, commit it, make changes, view the difference between those changes, and review the previous version. When you're done, you'll have a workflow you can apply to your own writing projects.

Вы можете сохранить этот вывод в файл, если он вам нужен:

git show 95fed84:./article.md > old_article.md

По мере того, как вы будете вносить изменения в текст, ваш лог будет расти. Позже вы сможете просматривать все изменения, внесенные в вашу статью с самого начала работы над ней.

Заключение

В этом мануале вы научились использовать локальный репозиторий Git для отслеживания изменений в текстах. Теперь вы можете использовать этот подход для управления вашими статьями, публикациями в блоге или даже текстом целой книги. Если вы отправите свой репозиторий на GitHub, вы можете привлечь других пользователей к работе над текстом.

Tags: Git

Info

A tutorial on Markdown and Git
Author: Zhengyi Peng zhengyi_peng@brown.edu
Source In Markdown

Table of Contents

  • Markdown: Syntax and Tools
  • Git: Basic Usages When Working Alone

Markdown

Markdown is a lightweight markup language with plain text formatting syntax.
Its design allows it to be converted to many output formats, but the original tool by the same name only supports HTML.
Markdown is often used to format readme files, for writing messages in online discussion forums, and to create rich text using a plain text editor.

Syntax

  • Official
  • Github

Apps and Integrations

  • Grip: Markdown Preview In Github Flavor

    Grip is a command-line server application written in Python that uses the GitHub markdown API to render a local readme file.
    The styles come directly from GitHub, so you’ll know exactly how it will appear.
    Changes you make to the Readme will be instantly reflected in the browser without requiring a page refresh.

    • Install:
      • $ pip install grip
      • $ brew install grip (MACOS)
    • Usage:
      • $ grip <markdown-file>
  • MacDown: open source Markdown editor for OS X
    app screenshot
  • vim-markdown

    Syntax highlighting, matching rules and mappings for the original Markdown and extensions.

Git

Git (/ɡɪt/) is a distributed version-control system for tracking changes in source code during software development.
It is designed for coordinating work among programmers, but it can be used to track changes in any set of files.
Its goals include speed, data integrity, and support for distributed, non-linear workflows.

GUI Clients

Command Line

Modeled after Git Immersion

A guided tour that walks through the fundamentals of Git, inspired by the premise that to know a thing is to do it.

Initializing a Repository in an Existing Directory

  • cd into the project folder

    $ mkdir d3-demo
    $ cd d3-demo
    
  • transforms a normal directory into a git directory
    git init

First Commit

$ touch d3-demo.html
$ git add d3-demo.html
$ git commit -m "create target file"

git add <file> add changes in files to the next commit

The string afters -m is the commit message, it’s always a good
idea to remind yourself why this commit is necessary and what’s
changed

Check The Current Status Of The Directory

$ git status
On branch master
nothing to commit, working tree clean

The output says there isn’t any untracked change from last commit

Modify and Commit New Changes

write a skeleton HTML page
<!doctype html>
<html lang="en">
    <head>
      <meta charset="utf-8">
      <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
      <title>CSCI1320: D3 Lecture Demo</title>
    </head>
    <body>
      <script>
      </script>
    </body>
</html>
git automatically finds out the changes in working directory
$ git status
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

  modified:   d3-demo.html

no changes added to commit (use "git add" and/or "git commit -a")
stage the changes
$ git add d3-demo.html
$ git status
On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

  modified:   d3-demo.html

When using git add, changes are tracked in the staging area.
Think staging area as accepted changes. Next git commit will record all changes in staging area.

commit the staged changes

If omitting the -m flag, you will need to write the commit message in an editor.

You can Change Editor.

By default, Git uses your system’s default editor, which is generally Vi or Vim.
If you want to use a different text editor, such as Emacs, you can do the following:

$ git config --global core.editor emacs

$ git commit

(inside default editor)

# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
#
# On branch master
# Changes to be committed:
# modified:   d3-demo.html
#

Puts commit message created HTML template in first line and save and exit.
For example, typing :x in normal mode in vim

git works with changes, not files
Git focuses on the changes to a file rather than the file itself.
When you say git add file, you are not telling git to add the file to the repository.
Rather you are saying that git should make note of the current state of that file to be committed later.

View Commit History

$ git log
commit 3958d73a146bce0af25fcec3781c724530875887 (HEAD -> master)
Author: pengzhengyi <zhengyi_peng@brown.edu>
Date:   Mon Apr 29 16:56:10 2019 -0400

    HTML template

commit b9b38b335a62cb70bd3681da7b536d66b39e9f7c
Author: pengzhengyi <zhengyi_peng@brown.edu>
Date:   Mon Apr 29 16:22:58 2019 -0400

    create target file

We can see the two commits made to this repository.

create alias (shorthand, abbreviations) for git commands

You can sepcify alias for git commands in .gitconfig file.
Create a .gitconfig file in your $HOME directory to mak configuration global
Alternatively, create a .gitconfig file in your current directory to make configuration local

Here is my .gitconfig file:

[color]
  branch = auto
  diff = auto
  status = auto
[color "branch"]
  current = yellow reverse
  local = yellow
  remote = green
[color "diff"]
  meta = yellow bold
  frag = magenta bold
  old = red bold
  new = green bold
[color "status"]
  added = yellow
  changed = green
  untracked = cyan
[filter "lfs"]
  clean = git-lfs clean -- %f
  smudge = git-lfs smudge -- %f
  process = git-lfs filter-process
  required = true
[user]
  name = <username>
  email = <email>
[pull]
  rebase = false
[alias]
  co = checkout
  ci = commit
  st = status
  br = branch
  hist = log --all --graph
  br = branch
  l = log --all --decorate --graph --pretty=oneline
  lv = log --all --decorate --graph --pretty=tformat:'commit: %C(bold red)%h%Creset %C(red)<%H>%Creset %C(bold magenta)%d %Creset%ndate: %C(bold yellow)%cd %Creset%C(yellow)%cr%Creset%nauthor: %C(bold blue)%an%Creset %C(blue)<%ae>%Creset%n%C(cyan)%s%n%Creset'
  type = cat-file -t
  dump = cat-file -p
  ignore = "!gi() { curl -L -s https://www.gitignore.io/api/$@ ;}; gi"
[core]
  autocrlf = false 
  safecrlf = false 

You can try git lv if you used the above configurations.

Get history versions

What’s a version control system good for if we cannot revert back to old versions?
Luckily, git allows us to easily travel back and force in commit.
Think your commits as snapshots of the repository.

Using the git log command, you can find the hash for every commits.
Think hash as identifier for each commit.

Your hash might be different from what I have:

* 3958d73a146bce0af25fcec3781c724530875887 (HEAD -> master) HTML template
* b9b38b335a62cb70bd3681da7b536d66b39e9f7c create target file
$ git checkout b9b38b335a62cb70bd3681da7b536d66b39e9f7c
Note: checking out 'b9b38b335a62cb70bd3681da7b536d66b39e9f7c'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b <new-branch-name>

HEAD is now at b9b38b3 create target file

git checkout <hash>takes us back to the commit specified by the hash.

If you use cat d3-demo.html, you will find its an empty file as our first commit just creates this file.

If you have set the configuration, you can run git lv, otherwise run git log --all --graph

$ git lv
* commit: 3958d73 <3958d73a146bce0af25fcec3781c724530875887>  (master)
| date: Mon Apr 29 16:56:10 2019 -0400 44 minutes ago
| author: pengzhengyi <zhengyi_peng@brown.edu>
| HTML template
|
* commit: b9b38b3 <b9b38b335a62cb70bd3681da7b536d66b39e9f7c>  (HEAD)
  date: Mon Apr 29 16:22:58 2019 -0400 77 minutes ago
  author: pengzhengyi <zhengyi_peng@brown.edu>
  create target file

HEAD is where we are currently at,

master’ is the name of the default branch.
By checking out a branch by name, you go to the latest version of that branch.

Use git checkout master to go back to latest commit.

Tagging a commit

If you do not reference a commit by hash every time, you can tag it by a custom name.

Checkout the first commit and use git tag initial to tag the first commit as initial.

Now you can travel back and forth using git checkout master and git checkout initial

Additionally, you can use git tag to view all defined tags.

Undoing Things

Unmodifying a Modified File

First, go back to master version git checkout master.

If you run git status, git should report working directory clean.

Pretend we have made some unwanted changes which haven’t not been staged (we have not run git add) yet.
echo "Unwanted Change" >> d3-demo.html
This command appends one line with string «Unwanted Change» to the end of the file.

When we run git status again, we will see d3-demo.html has been modified but changes have not been staged.

$ git status
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

  modified:   d3-demo.html

no changes added to commit (use "git add" and/or "git commit -a")

As it suggests, we can use git checkout d3-demo.html to discard the changes we have made.
You can confirm that the appended line has disappeared using tail d3-demo.html, a command to see the last lines of the file.

Unstaging a Staged File

Pretend we have made some unwanted changes and have staged these changes

$ echo "Unwanted Change" >> d3-demo.html
$ git add d3-demo.html
$ git status
On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

  modified:   d3-demo.html

Similarly, we can follow what the git status instructs us to do:
git reset HEAD d3-demo.html
Since we have checked out master branch, HEAD is equivalent to MASTER and refers to files in most recent commit.

However, we are not done yet, if you run git status again, you will find we end up in previous situation:
we have made some changes but have not staged these changes yet (the «Unwanted Change» line is still there).
Run git checkout d3-demo.html to reset the file.

If it’s okay to discard all changes (staged or unstaged), you can directly run git checkout <hash> to go back to a specific commit.

Undoing Committed Changes

Pretend we have made some unwanted changes and have committed these changes

$ echo "Unwanted Change" >> d3-demo.html
$ git add d3-demo.html
$ git commit -m "unwanted changes committed"

To revert back, we basically create an overwriting commit.
You can achieve the same effect by remove unwanted changes, add the file, and commit.

git revert HEAD --no-edit

git-revert revert the changes that the related patches introduce, and record some new commits that record them.

git revert is used to record some new commits to reverse the effect of some earlier commits (often only a faulty one).
If you want to throw away all uncommitted changes in your working directory, you should see git-reset[1], particularly the —hard option.
If you want to extract specific files as they were in another commit, you should see git-checkout[1], specifically the git checkout — syntax.
Take care with these alternatives as both will discard uncommitted changes in your working directory.

Git Branching

Creating A Branch

Typically, a stable version of an application is stored in the master branch.
When we plan to make some changes, we open a new branch and store changes in the new branch.
By separating the development application and the deployment application (the stable version),
we can make changes without worrying about potentially damaging effects.

We can create a new branch using
git checkout -b <branchname>

The command is a shortcut for git branch <branchname> followed by a git checkout <branchname>.

Navigating Branches

You can use git branch to view all branches and use git checkout <branchname> to navigate around branches.

Merging Branches

First, let us introduce a divergence — we add a README in dev branch while make some changes to d3-demo.html in master branch.

  • changes in dev branch

    $ git checkout dev
    Switched to branch 'dev'
    $ echo "This is a sample project for D3 visualization" >> README.md
    $ ls
    README.md    d3-demo.html
    $ git add README.md
    $ git commit -m "Added README"
  • changes in master branch

    $ git checkout master
    Switched to branch 'master'
    $ ls
    d3-demo.html

    Then we add the link to latest d3 release in d3-demo.html, put it just after the body tag
    <script src="https://d3js.org/d3.v5.min.js"></script>

    $ git add d3-demo.html
    $ git commit -m "include link to d3 script"

We can view the branches and how they diverge using

$ git log --all --graph
* commit d3453f85b737c41d2d9cfd8399910d29fb5aa5b8 (HEAD -> master)
| Author: pengzhengyi <zhengyi_peng@brown.edu>
| Date:   Fri May 3 06:02:45 2019 -0400
|
|     include link to d3 script
|
| * commit 57a38abd6494fbeabc6e7461c15cbc02d182374a (dev)
|/  Author: pengzhengyi <zhengyi_peng@brown.edu>
|   Date:   Fri May 3 05:53:48 2019 -0400
|
|       Added README
|
* commit 808a90528cfe295eb7e44080712fccb778ee99f8
| Author: pengzhengyi <zhengyi_peng@brown.edu>
| Date:   Wed May 1 10:35:53 2019 -0400
|
|     HTML Template
|
* commit ee15e447dff6c40fa4cc5ccdf7075af27963b999 (tag: initial)
  Author: pengzhengyi <zhengyi_peng@brown.edu>
  Date:   Wed May 1 10:31:23 2019 -0400

      create target file
(END)

The —all flag makes sure that we see all the branches. The default is to show only the current branch.
Adding the —graph option to git log causes it to draw the commit tree using simple ASCII characters.

Often we want to merge the changes in master branch to our development branch so that the developemnt branch
is up to date with recent changes in master while keep its local changes unaffected.
Now both branches contain independent changes. We can merge the changes from the master branch by:

$ git checkout dev
$ git merge master
$ git log --all --graph
*   commit 25e554a9a199bd8a3bbc9167916b182d599e96be (HEAD -> dev)
|  Merge: 57a38ab d3453f8
| | Author: pengzhengyi <zhengyi_peng@brown.edu>
| | Date:   Fri May 3 06:14:53 2019 -0400
| |
| |     Merge branch 'master' into dev
| |
| * commit d3453f85b737c41d2d9cfd8399910d29fb5aa5b8 (master)
| | Author: pengzhengyi <zhengyi_peng@brown.edu>
| | Date:   Fri May 3 06:02:45 2019 -0400
| |
| |     include link to d3 script
| |
* | commit 57a38abd6494fbeabc6e7461c15cbc02d182374a
|/  Author: pengzhengyi <zhengyi_peng@brown.edu>
|   Date:   Fri May 3 05:53:48 2019 -0400
|
|       Added README
|
* commit 808a90528cfe295eb7e44080712fccb778ee99f8
| Author: pengzhengyi <zhengyi_peng@brown.edu>
| Date:   Wed May 1 10:35:53 2019 -0400
|
|     HTML Template
|
* commit ee15e447dff6c40fa4cc5ccdf7075af27963b999 (tag: initial)
  Author: pengzhengyi <zhengyi_peng@brown.edu>
  Date:   Wed May 1 10:31:23 2019 -0400

      create target file

If we open the d3-demo.html, we can see changes from master branch is now included.
However, the new README.md in dev is not present if we switch to master branch.

Another way to achieve the same effect is using rebase command.
Instead of running git merge master, we will run git rebase master in dev branch.

Merge VS Rebase

The final result of the rebase is very similar to the merge. The greet branch now contains all of its changes, as well as all the changes from the master branch. However, the commit tree is quite different. The commit tree for the greet branch has been rewritten so that the master branch is a part of the commit history. This leaves the chain of commits linear and much easier to read.

When to Rebase, When to Merge?

Don’t use rebase …

If the branch is public and shared with others. Rewriting publicly shared branches will tend to screw up other members of the team.
When the exact history of the commit branch is important (since rebase rewrites the commit history).
Given the above guidelines, I tend to use rebase for short-lived, local branches and merge for branches in the public repository.

Resolving Conflicts

Sadly, things do not always go smoothly. Conflicts arise when you are merging two branches with conflicting changes.

  • changes to dev branch
    • Checkout the dev branch. git checkout dev
    • We add a svg element to d3-demo.html immediately after the body tag.
    • Commit this change. git add d3-demo.html and git commit -m "add svg element"
  • changes to master branch
    • Checkout the master branch. git checkout master
    • We add a div element to d3-demo.html immediately after the body tag.
    • Commit this change. git add d3-demo.html and git commit -m "add div element"

If we try to merge two branches, we will get a merge conflict.

$ git checkout master
$ git merge dev
Auto-merging d3-demo.html
CONFLICT (content): Merge conflict in d3-demo.html
Automatic merge failed; fix conflicts and then commit the result.

If you open the d3-demo.html, it will look like:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
  <title>CSCI1320: D3 Lecture Demo</title>
</head>
<body>
<<<<<<< HEAD
  <div>
  </div>
=======
  <svg>
  </svg>
>>>>>>> dev
  <script src="https://d3js.org/d3.v5.min.js"></script>
  <script>
  </script>
</body>
</html>

The first section is the version on the head of the current branch (master).
The second section is the version on the dev branch.

We need to manually resolve the conflict.
Some possible ways to resolve this conflict includes deleting one section and merging two sections.

For merging, we can modify the conflict part to be:

<body>
  <div>
    <svg>
    </svg>
  </div>
  <script src="https://d3js.org/d3.v5.min.js"></script>
  <script>
  </script>
</body>

Then we can commit the conflict resolution by git add d3-demo.html and git commit -m "nest svg element inside div element".

As it is a hassle to fix merge conflicts, it is preferable to avoid conflicts at the beginning.
This post gives out some Recommendations to avoid merge conflicts

Thanks For Reading

Понравилась статья? Поделить с друзьями:
  • Фебтал для крс инструкция по применению в ветеринарии
  • Закрытие года в 1с упп пошаговая инструкция
  • Harman kardon avr 745 инструкция на русском
  • Препарат свитч инструкция по применению отзывы
  • Panasonic nv fs200 инструкция на русском