diff options
Diffstat (limited to 'doc/development/documentation')
| -rw-r--r-- | doc/development/documentation/feature_flags.md | 182 | ||||
| -rw-r--r-- | doc/development/documentation/index.md | 122 | ||||
| -rw-r--r-- | doc/development/documentation/site_architecture/index.md | 9 | ||||
| -rw-r--r-- | doc/development/documentation/site_architecture/release_process.md | 5 | ||||
| -rw-r--r-- | doc/development/documentation/structure.md | 232 | ||||
| -rw-r--r-- | doc/development/documentation/styleguide.md | 1147 | ||||
| -rw-r--r-- | doc/development/documentation/workflow.md | 2 |
7 files changed, 1022 insertions, 677 deletions
diff --git a/doc/development/documentation/feature_flags.md b/doc/development/documentation/feature_flags.md index e2fbf25eb8a..a4a6ee2fa0f 100644 --- a/doc/development/documentation/feature_flags.md +++ b/doc/development/documentation/feature_flags.md @@ -1,5 +1,8 @@ --- -type: reference +type: reference, dev +stage: none +group: Development +info: "See the Technical Writers assigned to Development Guidelines: https://about.gitlab.com/handbook/engineering/ux/technical-writing/#assignments-to-development-guidelines" description: "GitLab development - how to document features deployed behind feature flags" --- @@ -24,6 +27,7 @@ See how to document them below, according to the state of the flag: - [Features disabled by default](#features-disabled-by-default). - [Features that became enabled by default](#features-that-became-enabled-by-default). - [Features directly enabled by default](#features-directly-enabled-by-default). +- [Features that can be enabled or disabled for a single project](#features-enabled-by-project). - [Features with the feature flag removed](#features-with-flag-removed). NOTE: **Note:** @@ -37,105 +41,120 @@ therefore, it indicates that it cannot be done by regular users of GitLab.com. For features disabled by default, if they cannot be used yet due to lack of completeness, or if they're still under internal evaluation (for example, for performance implications) do **not document them**: add (or merge) the docs -only when the feature is safe and ready to use and test by end users. +only when the feature is safe and ready to use and test by end-users. For feature flags disabled by default, if they can be used by end users: - Say that it's disabled by default. - Say whether it's enabled on GitLab.com. -- Say whether it can be enabled or disabled per-project. +- If the feature can be enabled/disabled for a single project, add the + [by-project information](#features-enabled-by-project). Otherwise, + do not say anything about it. - Say whether it's recommended for production use. - Document how to enable and disable it. +- Add a warning to the user saying that the feature is disabled. -For example, for a feature disabled by default, disabled on GitLab.com, can be enabled or disabled per-project, and -not ready for production use: +For example, for a feature disabled by default, disabled on GitLab.com, cannot +be enabled for a single project, and is not ready for production use: ````markdown # Feature Name > - [Introduced](link-to-issue) in GitLab 12.0. -> - It's deployed behind a feature flag, disabled by default. +> - It's [deployed behind a feature flag](<replace with path to>/user/feature_flags.md), disabled by default. > - It's disabled on GitLab.com. -> - It's able to be enabled or disabled per-project. > - It's not recommended for production use. > - To use it in GitLab self-managed instances, ask a GitLab administrator to [enable it](#anchor-to-section). **(CORE ONLY)** -(...) +CAUTION: **Warning:** +This feature might not be available to you. Check the **version history** note above for details. + +(...Regular content goes here...) + +<!-- Add this at the end of the file --> ### Enable or disable <Feature Name> **(CORE ONLY)** <Feature Name> is under development and not ready for production use. It is deployed behind a feature flag that is **disabled by default**. -[GitLab administrators with access to the GitLab Rails console](../path/to/administration/feature_flags.md) -can enable it for your instance. <Feature Name> can be enabled or disabled per-project. +[GitLab administrators with access to the GitLab Rails console](<replace with path to>/administration/feature_flags.md) +can enable it. To enable it: ```ruby -# Instance-wide Feature.enable(:<feature flag>) -# or by project -Feature.enable(:<feature flag>, Project.find(<project id>)) ``` To disable it: ```ruby -# Instance-wide Feature.disable(:<feature flag>) -# or by project -Feature.disable(:<feature flag>, Project.find(<project id>)) ``` ```` Adjust the blurb according to the state of the feature you're documenting. +Replace `<Feature name>`, `**(CORE ONLY)**`, `<feature flag>`, and +`<replace with path to>`, and `#anchor-to-section` accordingly. ### Features that became enabled by default -For features that became enabled by default: +For features that were released disabled by default but became enabled by +default: - Say that it became enabled by default. - Say whether it's enabled on GitLab.com. -- Say whether it can be enabled or disabled per-project. +- If the feature can be enabled/disabled for a single project, add the + [by-project information](#features-enabled-by-project). Otherwise, + do not say anything about it. - Say whether it's recommended for production use. - Document how to disable and enable it. +- Add a warning to the user saying that the feature might be disabled. -For example, for a feature initially deployed disabled by default, that became enabled by default, that is enabled on GitLab.com, that cannot be enabled or disabled per-project, and ready for production use: +For example, for a feature initially deployed disabled by default, that became +enabled by default, that is enabled on GitLab.com, and is ready for production +use: ````markdown # Feature Name > - [Introduced](link-to-issue) in GitLab 12.0. -> - It was deployed behind a feature flag, disabled by default. +> - It was [deployed behind a feature flag](<replace with path to>/user/feature_flags.md), disabled by default. > - [Became enabled by default](link-to-issue) on GitLab 12.1. > - It's enabled on GitLab.com. -> - It's not able to be enabled or disabled per-project. > - It's recommended for production use. > - For GitLab self-managed instances, GitLab administrators can opt to [disable it](#anchor-to-section). **(CORE ONLY)** -(...) +CAUTION: **Warning:** +This feature might not be available to you. Check the **version history** note above for details. + +(...Regular content goes here...) + +<!-- Add this at the end of the file --> ### Enable or disable <Feature Name> **(CORE ONLY)** <Feature Name> is under development but ready for production use. It is deployed behind a feature flag that is **enabled by default**. -[GitLab administrators with access to the GitLab Rails console](..path/to/administration/feature_flags.md) -can opt to disable it for your instance it cannot be enabled or disabled per-project. +[GitLab administrators with access to the GitLab Rails console](<replace with path to>/administration/feature_flags.md) +can opt to disable it. -To disable it: +To enable it: ```ruby -Feature.disable(:<feature flag>) +Feature.enable(:<feature flag>) ``` -To enable it: +To disable it: ```ruby -Feature.enable(:<feature flag>) +Feature.disable(:<feature flag>) ``` ```` Adjust the blurb according to the state of the feature you're documenting. +Replace `<Feature name>`, `**(CORE ONLY)**`, `<feature flag>`, +`<replace with path to>`, and `#anchor-to-section` accordingly. ### Features directly enabled by default @@ -143,45 +162,134 @@ For features enabled by default: - Say it's enabled by default. - Say whether it's enabled on GitLab.com. -- Say whether it can be enabled or disabled per-project. +- If the feature can be enabled/disabled for a single project, add the + [by-project information](#features-enabled-by-project). Otherwise, + do not say anything about it. - Say whether it's recommended for production use. - Document how to disable and enable it. +- Add a warning to the user saying that the feature might be disabled. -For example, for a feature enabled by default, enabled on GitLab.com, cannot be enabled or disabled per-project, and ready for production use: +For example, for a feature enabled by default, enabled on GitLab.com, that +cannot be enabled for a single project, and is ready for production use: ````markdown # Feature Name > - [Introduced](link-to-issue) in GitLab 12.0. -> - It's deployed behind a feature flag, enabled by default. +> - It's [deployed behind a feature flag](<replace with path to>/user/feature_flags.md), enabled by default. > - It's enabled on GitLab.com. -> - It's not able to be enabled or disabled per-project. > - It's recommended for production use. > - For GitLab self-managed instances, GitLab administrators can opt to [disable it](#anchor-to-section). **(CORE ONLY)** -(...) +CAUTION: **Warning:** +This feature might not be available to you. Check the **version history** note above for details. + +(...Regular content goes here...) + +<!-- Add this at the end of the file --> ### Enable or disable <Feature Name> **(CORE ONLY)** <Feature Name> is under development but ready for production use. It is deployed behind a feature flag that is **enabled by default**. -[GitLab administrators with access to the GitLab Rails console](..path/to/administration/feature_flags.md) -can opt to disable it for your instance. +[GitLab administrators with access to the GitLab Rails console](<replace with path to>/administration/feature_flags.md) +can opt to disable it. + +To enable it: + +```ruby +Feature.enable(:<feature flag>) +``` To disable it: ```ruby Feature.disable(:<feature flag>) ``` +```` -To enable it: +Adjust the blurb according to the state of the feature you're documenting. +Replace `<Feature name>`, `**(CORE ONLY)**`, `<feature flag>`, +`<replace with path to>`, and `#anchor-to-section` accordingly. + +### Features enabled by project + +If the feature can be enabled/disabled for a single project, include in the +version history note: + +```markdown +> - It can be enabled or disabled for a single project. +``` + +Then add the by-project code to the code blocks: + +Enable code: + +```ruby +# For the instance +Feature.enable(:<feature flag>) +# For a single project +Feature.enable(:<feature flag>, Project.find(<project id>)) +``` + +Disable code: + +```ruby +# For the instance +Feature.disable(:<feature flag>) +# For a single project +Feature.disable(:<feature flag>, Project.find(<project id>)) +``` + +For example, for a feature enabled by default, enabled on GitLab.com, that can +be enabled by project, and is ready for production use: + +````markdown +# Feature Name + +> - [Introduced](link-to-issue) in GitLab 12.0. +> - It's [deployed behind a feature flag](<replace with path to>/user/feature_flags.md), enabled by default. +> - It's enabled on GitLab.com. +> - It can be enabled or disable for a single project. +> - It's recommended for production use. +> - For GitLab self-managed instances, GitLab administrators can opt to [disable it](#anchor-to-section). **(CORE ONLY)** + +CAUTION: **Warning:** +This feature might not be available to you. Check the **version history** note above for details. + +(...Regular content goes here...) + +<!-- Add this at the end of the file --> + +### Enable or disable <Feature Name> **(CORE ONLY)** + +<Feature Name> is under development but ready for production use. +It is deployed behind a feature flag that is **enabled by default**. +[GitLab administrators with access to the GitLab Rails console](<replace with path to>/administration/feature_flags.md) +can opt to disable it. + +To enabled it: ```ruby +# For the instance Feature.enable(:<feature flag>) +# For a single project +Feature.enable(:<feature flag>, Project.find(<project id>)) +``` + +To disable it: + +```ruby +# For the instance +Feature.disable(:<feature flag>) +# For a single project +Feature.disable(:<feature flag>, Project.find(<project id>)) ``` ```` Adjust the blurb according to the state of the feature you're documenting. +Replace `<Feature name>`, `**(CORE ONLY)**`, `<feature flag>`, +`<replace with path to>`, and `#anchor-to-section` accordingly. ### Features with flag removed @@ -195,6 +303,6 @@ mentions the flag in the version history notes: > - [Introduced](link-to-issue) in GitLab 12.0. > - [Feature flag removed](link-to-issue) in GitLab 12.2. -(...) +(...Regular content...) ```` diff --git a/doc/development/documentation/index.md b/doc/development/documentation/index.md index 283060ba8d4..d6f24d6374d 100644 --- a/doc/development/documentation/index.md +++ b/doc/development/documentation/index.md @@ -105,22 +105,22 @@ info: To determine the technical writer assigned to the Stage/Group associated w --- ``` -### Page type metadata +### Document type metadata Originally discussed in [this epic](https://gitlab.com/groups/gitlab-org/-/epics/1280), -each page should have a `type` metadata. It can be one or more of the following: - -- `index`: Index/overview pages. They serve as a list to other pages. Doesn't - necessarily mean the page should be named `index.md`. [Example page](../../install/README.md). -- `concepts`: What you need to know before using product. Informational, not - instructional. For example, abstract ideas, explain meaning or benefit, support - understanding of tasks. They are read for background information, for example - "Why X is important". [Example page](../../topics/autodevops/index.md). -- `howto`: Specific use case instructions. [Example page](../../ssh/README.md). -- `tutorial`: Learn a process/concept by doing. [Example page](../../gitlab-basics/start-using-git.md). -- `reference`: Covers what things are/do. Things like specific settings, facts - without too much explanation that are read for detailed information. - [Example page](../../ci/yaml/README.md). +each page should have a metadata tag called `type`. It can be one or more of the +following: + +- `index`: It consists mostly of a list of links to other pages. + [Example page](../../README.md). +- `concepts`: The background or context of a subject. + [Example page](../../topics/autodevops/index.md). +- `howto`: Specific use case instructions. + [Example page](../../ssh/README.md). +- `tutorial`: Learn a process/concept by doing. + [Example page](../../gitlab-basics/start-using-git.md). +- `reference`: A collection of information used as a reference to use a feature + or a functionality. [Example page](../../ci/yaml/README.md). ### Redirection metadata @@ -147,17 +147,10 @@ comments: false ### Additional page metadata -Each page can have additional (optional) metadata (set in the +Each page can have additional, optional metadata (set in the [default.html](https://gitlab.com/gitlab-org/gitlab-docs/-/blob/fc3577921343173d589dfa43d837b4307e4e620f/layouts/default.html#L30-52) -Nanoc layout), which will be shown to the top of the page if defined: - -- `author`: The name of the author of a page, usually a tutorial. It requires `author_gitlab` in order to be shown. -- `author_gitlab`: The username of the author on GitLab.com. It requires `author` in order to be shown. -- `date`: The date the page was created, usually for tutorials. -- `article_type`: The type of article. Can be either `tutorial` or `user guide`. -- `level`: The level of complexity of a how-to or tutorial. Can be either `beginner`, - `advanced`, or `intermediate`. -- `last_updated`: The date in ISO format when the page was last updated. For example `2020-02-14`. +Nanoc layout), which will be displayed at the top of the page if defined: + - `reading_time`: If you want to add an indication of the approximate reading time of a page, you can set `reading_time` to `true`. This uses a simple [algorithm](https://gitlab.com/gitlab-org/gitlab-docs/-/blob/master/lib/helpers/reading_time.rb) @@ -335,12 +328,12 @@ You can combine one or more of the following: = link_to 'Help page', help_page_path('user/permissions'), target: '_blank' ``` -1. **Linking to a circle icon.** Usually used in settings where a long +1. **Using a question icon.** Usually used in settings where a long description cannot be used, like near checkboxes. You can basically use - any font awesome icon, but prefer the `question-circle`: + any GitLab SVG icon, but prefer the `question-o`: ```haml - = link_to icon('question-circle'), help_page_path('user/permissions') + = link_to sprite_icon('question-o'), help_page_path('user/permissions') ``` 1. **Using a button link.** Useful in places where text would be out of context @@ -462,7 +455,7 @@ If you want to know the in-depth details, here's what's really happening: [skips the test jobs](https://gitlab.com/gitlab-org/gitlab-docs/blob/8d5d5c750c602a835614b02f9db42ead1c4b2f5e/.gitlab-ci.yml#L50-55) to lower the build time. 1. Once the docs site is built, the HTML files are uploaded as artifacts. -1. A specific Runner tied only to the docs project, runs the Review App job +1. A specific runner tied only to the docs project, runs the Review App job that downloads the artifacts and uses `rsync` to transfer the files over to a location where NGINX serves them. @@ -472,7 +465,7 @@ The following GitLab features are used among others: - [Multi project pipelines](../../ci/multi_project_pipeline_graphs.md) - [Review Apps](../../ci/review_apps/index.md) - [Artifacts](../../ci/yaml/README.md#artifacts) -- [Specific Runner](../../ci/runners/README.md#prevent-a-specific-runner-from-being-enabled-for-other-projects) +- [Specific runner](../../ci/runners/README.md#prevent-a-specific-runner-from-being-enabled-for-other-projects) - [Pipelines for merge requests](../../ci/merge_request_pipelines/index.md) ## Testing @@ -701,9 +694,9 @@ To configure markdownlint within your editor, install one of the following as ap To configure Vale within your editor, install one of the following as appropriate: -- The Sublime Text [`SublimeLinter-contrib-vale` plugin](https://packagecontrol.io/packages/SublimeLinter-contrib-vale) -- The Visual Studio Code [`testthedocs.vale` extension](https://marketplace.visualstudio.com/items?itemName=testthedocs.vale) -- [Vim](https://github.com/dense-analysis/ale) +- The Sublime Text [`SublimeLinter-contrib-vale` plugin](https://packagecontrol.io/packages/SublimeLinter-contrib-vale). +- The Visual Studio Code [`errata-ai.vale-server` extension](https://marketplace.visualstudio.com/items?itemName=errata-ai.vale-server). You don't need Vale Server to use the plugin. +- [Vim](https://github.com/dense-analysis/ale). We don't use [Vale Server](https://errata-ai.github.io/vale/#using-vale-with-a-text-editor-or-another-third-party-application). @@ -736,9 +729,7 @@ document: - To disable all Vale linting rules, add a `<!-- vale off -->` tag before the text, and a `<!-- vale on -->` tag after the text. -Whenever possible, exclude only the problematic rule and line(s). In some cases, such as list items, -you may need to disable linting for the entire list until -[Vale issue #175](https://github.com/errata-ai/vale/issues/175) is resolved. +Whenever possible, exclude only the problematic rule and line(s). For more information, see [Vale's documentation](https://errata-ai.gitbook.io/vale/getting-started/markup#markup-based-configuration). @@ -750,3 +741,64 @@ code review. For docs changes in merge requests, whenever a change to files unde is made, Danger Bot leaves a comment with further instructions about the documentation process. This is configured in the `Dangerfile` in the GitLab repository under [/danger/documentation/](https://gitlab.com/gitlab-org/gitlab/tree/master/danger/documentation). + +## Automatic screenshot generator + +You can now set up an automatic screenshot generator to take and compress screenshots, with the +help of a configuration file known as **screenshot generator**. + +### Use the tool + +To run the tool on an existing screenshot generator, take the following steps: + +1. Set up the [GitLab Development Kit (GDK)](https://gitlab.com/gitlab-org/gitlab-development-kit/blob/master/doc/howto/gitlab_docs.md). +1. Navigate to the subdirectory with your cloned GitLab repository, typically `gdk/gitlab`. +1. Make sure that your GDK database is fully migrated: `bin/rake db:migrate RAILS_ENV=development`. +1. Install pngquant, see the tool website for more info: [`pngquant`](https://pngquant.org/) +1. Run `scripts/docs_screenshots.rb spec/docs_screenshots/<name_of_screenshot_generator>.rb <milestone-version>`. +1. Identify the location of the screenshots, based on the `gitlab/doc` location defined by the `it` parameter in your script. +1. Commit the newly created screenshots. + +### Extending the tool + +To add an additional **screenshot generator**, take the following steps: + +- Locate the `spec/docs_screenshots` directory. +- Add a new file with a `_docs.rb` extension. +- Be sure to include the following bits in the file: + +```ruby +require 'spec_helper' + +RSpec.describe '<What I am taking screenshots of>', :js do + include DocsScreenshotHelpers # Helper that enables the screenshots taking mechanism + + before do + page.driver.browser.manage.window.resize_to(1366, 1024) # length and width of the page + end +``` + +- In addition, every `it` block must include the path where the screenshot is saved + +```ruby + it 'user/packages/container_registry/img/project_image_repositories_list' +``` + +#### Full page screenshots + +To take a full page screenshot simply `visit the page` and perform any expectation on real content (to have capybara wait till the page is ready and not take a white screenshot). + +#### Element screenshot + +To have the screenshot focuses few more steps are needed: + +- **find the area**: `screenshot_area = find('#js-registry-policies')` +- **scroll the area in focus**: `scroll_to screenshot_area` +- **wait for the content**: `expect(screenshot_area).to have_content 'Expiration interval'` +- **set the crop area**: `set_crop_data(screenshot_area, 20)` + +In particular `set_crop_data` accepts as arguments: a `DOM` element and a padding, the padding will be added around the element enlarging the screenshot area. + +#### Live example + +Please use `spec/docs_screenshots/container_registry_docs.rb` as a guide and as an example to create your own scripts. diff --git a/doc/development/documentation/site_architecture/index.md b/doc/development/documentation/site_architecture/index.md index 63cd9959985..5d3af6721d1 100644 --- a/doc/development/documentation/site_architecture/index.md +++ b/doc/development/documentation/site_architecture/index.md @@ -227,11 +227,12 @@ for its search function. This is how it works: there's a JavaScript snippet which initiates DocSearch by using an API key and an index name (`gitlab`) that are needed for Algolia to show the results. -NOTE: **For GitLab employees:** -The credentials to access the Algolia dashboard are stored in 1Password. If you -want to receive weekly reports of the search usage, search the Google doc with +NOTE: **For GitLab Team Members:** +If you’re a GitLab Team Member, find credentials for the Algolia dashboard +in the shared [GitLab 1Password account](https://about.gitlab.com/handbook/security/#1password-for-teams). +To receive weekly reports of the search usage, search the Google doc with title `Email, Slack, and GitLab Groups and Aliases`, search for `docsearch`, -and add a comment with your email to be added to the alias that gets the weekly +and add a comment with your email. You'll be added to the alias that gets the weekly reports. ## Monthly release process (versions) diff --git a/doc/development/documentation/site_architecture/release_process.md b/doc/development/documentation/site_architecture/release_process.md index d04d34ff786..98bb116aba6 100644 --- a/doc/development/documentation/site_architecture/release_process.md +++ b/doc/development/documentation/site_architecture/release_process.md @@ -121,11 +121,10 @@ versions (stable branches `X.Y` of the `gitlab-docs` project): pipelines succeed: NOTE: **Note:** - The `release-X-Y` branch needs to be present locally, - and you need to have switched to it, otherwise the Rake task will fail. + The `release-X-Y` branch needs to be present locally, otherwise the Rake + task will abort. ```shell - git checkout release-X-Y ./bin/rake release:dropdowns ``` diff --git a/doc/development/documentation/structure.md b/doc/development/documentation/structure.md index e13b2f4d031..e454a401a9d 100644 --- a/doc/development/documentation/structure.md +++ b/doc/development/documentation/structure.md @@ -1,45 +1,46 @@ --- +stage: none +group: Style Guide +info: To determine the technical writer assigned to the Stage/Group associated with this page, see https://about.gitlab.com/handbook/engineering/ux/technical-writing/#designated-technical-writers description: What to include in GitLab documentation pages. --- # Documentation structure and template -This document will help you determine how to structure a page within GitLab's -documentation and what content to include. These standards help ensure consistency -and completeness throughout the documentation, and they make it easier to contribute. +Use these standards to contribute content to the GitLab documentation. Before getting started, familiarize yourself with [GitLab's Documentation guidelines](index.md) -and the section on Content in the [Style Guide](styleguide.md). +and the [Documentation Style Guide](styleguide.md). ## Components of a documentation page -Most pages will be dedicated to a specific GitLab feature or to a use case that involves -one or more features, potentially in conjunction with third-party tools. - -Every feature or use case document should include the following content in the following sequence, -with exceptions and details noted below and in the template included on this page. - -- **Title**: Top-level heading with the feature name, or a use case name, which would start with - a verb, like "Configure", "Enable", and so on. -- **Introduction**: A couple sentences about the subject matter and what's to be found -on this page. Describe what the feature or topic is, what it does, and in what context it should -be used. There is no need to add a title called "Introduction" or "Overview," because people rarely - search for these terms. Just put this information after the title. -- **Use cases**: describes real use case scenarios for that feature/configuration. -- **Requirements**: describes what software, configuration, account, or knowledge is required. -- **Instructions**: one or more sets of detailed instructions to follow. -- **Troubleshooting** guide (recommended but not required). - -For additional details on each, see the [template for new docs](#template-for-new-docs), -below. - -Note that you can include additional subsections, as appropriate, such as 'How it Works', 'Architecture', -and other logical divisions such as pre-deployment and post-deployment steps. +Most pages are dedicated to a specific GitLab feature or to a use case that +involves one or more features, potentially in conjunction with third-party tools. + +In general, each topic should include the following content, in this sequence: + +- *Metadata*: Information about the stage, group, and how to find the technical + writer for the topic. This information isn't visible in the published help. +- *Title*: A top-level heading with the feature or use case name. Choose a term + that defines the functionality and use the same term in all the resources + where the feature is mentioned. +- *Introduction*: In a few sentences beneath the title, describe what the + feature or topic is, what it does, and in what context it should be used. +- *Use cases*: Describe real user scenarios. +- *Prerequisites*: Describe the software, configuration, account, permissions, + or knowledge required to use this functionality. +- *Tasks*: Present detailed step-by-step instructions on how to use the feature. +- *Troubleshooting*: List errors and how to address them. Recommended but not + required. + +You can include additional subsections, as appropriate, such as *How it Works*, +or *Architecture*. You can also include other logical divisions, such as +pre-deployment and post-deployment tasks. ## Template for new docs -To start a new document, respect the file tree and file name guidelines, -as well as the style guidelines. Use the following template: +Follow the [folder structure and file name guidelines](styleguide.md#folder-structure-overview) +and create a new topic by using this template: ```markdown <!--Follow the Style Guide when working on this document. @@ -47,94 +48,87 @@ https://docs.gitlab.com/ee/development/documentation/styleguide.html When done, remove all of this commented-out text, except a commented-out Troubleshooting section, which, if empty, can be left in place to encourage future use.--> --- -description: "Short document description." # Up to ~200 chars long. They will be displayed +description: "Short document description." # Up to ~200 chars long. This information is displayed in Google Search snippets. It may help to write the page intro first, and then reuse it here. -stage: "Add the stage name here, and remove the quotation marks" -group: "Add the group name here, and remove the quotation marks" +stage: Add the stage name here +group: Add the group name here info: To determine the technical writer assigned to the Stage/Group associated with this page, see https://about.gitlab.com/handbook/engineering/ux/technical-writing/#designated-technical-writers --- -# Feature Name or Use Case Name **[TIER]** (1) -<!--If writing about a use case, drop the tier, and start with a verb, +# Feature or Use Case Name **[TIER]** (1) +<!--If you are writing about a use case, start with a verb, for example, "Configure", "Implement", + the goal/scenario--> <!--For pages on newly-introduced features, add the following line. If only some aspects of the feature have been introduced, specify which parts of the feature.--> > [Introduced](link_to_issue_or_mr) in GitLab (Tier) X.Y (2). -An introduction -- without its own additional header -- goes here. -Offer a description of the feature or use case, and what to expect on this page. -(You can reuse this content, or part of it, for the front matter's `description` at the top -of this file). - -The introduction should answer the following questions: +Write a description of the feature or use case. This introduction should answer +these questions: - What is this feature or use case? - Who is it for? -- What is the context in which it is used and are there any prerequisites/requirements? -- What can the audience do with this? (Be sure to consider all applicable audiences, like - GitLab admin and developer-user.) -- What are the benefits to using this over any alternatives? +- What is the context in which it is used and are there any prerequisites or + requirements? +- What can the audience do with this? (Be sure to consider all applicable + audiences, such as GitLab admin and developer-user.) +- What are the benefits of using this over any existing alternatives? + +You can reuse this content, or part of it, for the front matter's `description` +at the top of this file. ## Use cases -Describe some use cases, typically in bulleted form. Include real-life examples for each. +Describe common use cases, typically in bulleted form. Include real-life examples +for each. -If the page itself is dedicated to a use case, this section can usually include more specific -scenarios for use (for example, variations on the main use case), but if that's not applicable, -the section can be omitted. +If the page itself is dedicated to a use case, this section usually includes more +specific scenarios for use (for example, variations on the main use case), but if +that's not applicable, you can omit this section. Examples of use cases on feature pages: + - CE and EE: [Issues](../../user/project/issues/index.md#use-cases) - CE and EE: [Merge Requests](../../user/project/merge_requests/index.md) -- EE-only: [Geo](../../administration/geo/replication/index.md) +- EE-only: [Geo](../../administration/geo/index.md) - EE-only: [Jenkins integration](../../integration/jenkins.md) -## Requirements +## Prerequisites -State any requirements for using the feature and/or following along with the instructions. +State any prerequisites for using the feature. These might include: -These can include both: -- technical requirements (for example, an account on a third party service, an amount of storage space, - prior configuration of another feature) -- prerequisite knowledge (for example, familiarity with certain GitLab features, cloud technologies) +- Technical prereqs (for example, an account on a third-party service, an amount + of storage space, or prior configuration of another feature) +- Prerequisite knowledge (for example, familiarity with certain GitLab features + or other products and technologies). Link each one to an appropriate place for more information. -## Instructions +## Tasks -This is the part of the document where you can include one or more sets of instructions. Each topic should help users accomplish a specific task. -Headers should describe the task the reader will achieve by following the instructions within, -typically starting with a verb. For example, `Create a package` or `Configure a pipeline`. +The heading should: + +- Describe the task and start with a verb. For example, `Create a package` or + `Configure a pipeline`. +- Be short and descriptive (up to ~50 chars). +- Start from an `h2` (`##`), then go over `h3`, `h4`, `h5`, and `h6` as needed. + Never skip a hierarchy level (like `h2` > `h4`). It breaks the table of + contents and can affect the breadcrumbs. -Larger instruction sets may have subsections covering specific phases of the process. -Where appropriate, provide examples of code or configuration files to better clarify -intended usage. +Bigger tasks can have subsections that explain specific phases of the process. -- Write a step-by-step guide, with no gaps between the steps. -- Include example code or configurations as part of the relevant step. - Use appropriate Markdown to wrap code blocks with - [syntax highlighting](../../user/markdown.md#colored-code-and-syntax-highlighting). -- Start with an h2 (`##`), break complex steps into small steps using - subheadings h3 > h4 > h5 > h6. _Never skip a hierarchy level, such - as h2 > h4_, as it will break the TOC and may affect the breadcrumbs. -- Use short and descriptive headings (up to ~50 chars). You can use one - single heading like `## Configure X` for instructions when the feature - is simple and the document is short. +Include example code or configurations when needed. Use Markdown to wrap code +blocks with [syntax highlighting](../../user/markdown.md#colored-code-and-syntax-highlighting). Example topic: ## Create a teddy bear -Start by writing a sentence or two about _why_ someone would want to perform this task. -It's not always possible, but is a good practice. For example: - -Create a teddy bear when you need something to hug. - -Follow this information with the task steps. +Create a teddy bear when you need something to hug. (Include the reason why you +might do the task.) To create a teddy bear: @@ -142,40 +136,40 @@ To create a teddy bear: 1. Expand **This** and click **This**. 1. Do another step. -After the numbered list, add a sentence with the expected result, if it -is not obvious, and any next steps. For example: - -The teddy bear is now in the kitchen, in the cupboard above the sink. +The teddy bear is now in the kitchen, in the cupboard above the sink. _(This is the result.)_ -You can retrieve the teddy bear and put it on the couch with the other animals. +You can retrieve the teddy bear and put it on the couch with the other animals. _(These are next steps.)_ -Screenshots are not necessary. They are difficult to keep up-to-date and can clutter the page. +Screenshots are not necessary. They are difficult to keep up-to-date and can +clutter the page. <!-- ## Troubleshooting -Include any troubleshooting steps that you can foresee. If you know beforehand what issues -one might have when setting this up, or when something is changed, or on upgrading, it's -important to describe those, too. Think of things that may go wrong and include them here. -This is important to minimize requests for support, and to avoid doc comments with -questions that you know someone might ask. +Include any troubleshooting steps that you can foresee. If you know beforehand +what issues one might have when setting this up, or when something is changed, +or on upgrading, it's important to describe those, too. Think of things that may +go wrong and include them here. This is important to minimize requests for +Support, and to avoid documentation comments with questions that you know +someone might ask. Each scenario can be a third-level heading, for example, `### Getting error message X`. -If you have none to add when creating a doc, leave this section in place -but commented out to help encourage others to add to it in the future. --> +If you have none to add when creating a doc, leave this section in place but +commented out to help encourage others to add to it in the future. --> --- Notes: -- (1): Apply the [tier badges](styleguide.md#product-badges) accordingly +- (1): Apply the [tier badges](styleguide.md#product-badges) accordingly. - (2): Apply the correct format for the - [GitLab version that introduces the feature](styleguide.md#gitlab-versions-and-tiers) + [GitLab version that introduces the feature](styleguide.md#gitlab-versions-and-tiers). ``` ## Help and feedback section -The "help and feedback" section (introduced by [!319](https://gitlab.com/gitlab-org/gitlab-docs/-/merge_requests/319)) displayed at the end of each document -can be omitted from the doc by adding a key into the its front matter: +This section ([introduced](https://gitlab.com/gitlab-org/gitlab-docs/-/merge_requests/319) in GitLab 11.4) +is displayed at the end of each document and can be omitted by adding a key into +the front matter: ```yaml --- @@ -183,8 +177,8 @@ feedback: false --- ``` -The default is to leave it there. If you want to omit it from a document, -you must check with a technical writer before doing so. +The default is to leave it there. If you want to omit it from a document, you +must check with a technical writer before doing so. ### Disqus @@ -192,8 +186,8 @@ We also have integrated the docs site with Disqus (introduced by [!151](https://gitlab.com/gitlab-org/gitlab-docs/-/merge_requests/151)), allowing our users to post comments. -To omit only the comments from the feedback section, use the following -key on the front matter: +To omit only the comments from the feedback section, use the following key in +the front matter: ```yaml --- @@ -201,36 +195,42 @@ comments: false --- ``` -We are only hiding comments in main index pages, such as [the main documentation index](../../README.md), since its content is too broad to comment on. Before omitting Disqus, -you must check with a technical writer. +We're hiding comments only in main index pages, such as [the main documentation index](../../README.md), +since its content is too broad to comment on. Before omitting Disqus, you must +check with a technical writer. -Note that once `feedback: false` is added to the front matter, it will automatically omit +Note that after adding `feedback: false` to the front matter, it will omit Disqus, therefore, don't add both keys to the same document. -The click events in the feedback section are tracked with Google Tag Manager. The -conversions can be viewed on Google Analytics by navigating to **Behavior > Events > Top events > docs**. +The click events in the feedback section are tracked with Google Tag Manager. +The conversions can be viewed on Google Analytics by navigating to +**Behavior > Events > Top events > docs**. ## Guidelines for good practices > [Introduced](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/36576/) in GitLab 13.2 as GitLab Development documentation. -"Good practice" examples demonstrate encouraged ways of writing code while comparing with examples of practices to avoid. -These examples are labeled as "Bad" or "Good". -In GitLab development guidelines, when presenting the cases, it is recommended -to follow a **first-bad-then-good** strategy. First demonstrate the "Bad" practice (how things _could_ be done, which is often still working code), -and then how things _should_ be done better, using a "Good" example. This is typically an improved example of the same code. +*Good practice* examples demonstrate encouraged ways of writing code while +comparing with examples of practices to avoid. These examples are labeled as +*Bad* or *Good*. In GitLab development guidelines, when presenting the cases, +it's recommended to follow a *first-bad-then-good* strategy. First demonstrate +the *Bad* practice (how things *could* be done, which is often still working +code), and then how things *should* be done better, using a *Good* example. This +is typically an improved example of the same code. Consider the following guidelines when offering examples: -- First, offer the "Bad" example, then the "Good" one. +- First, offer the *Bad* example, and then the *Good* one. - When only one bad case and one good case is given, use the same code block. -- When more than one bad case or one good case is offered, use separated code blocks for each. -With many examples being presented, a clear separation helps the reader to go directly to the good part. -Consider offering an explanation (for example, a comment, a link to a resource, etc.) on why something is bad practice. +- When more than one bad case or one good case is offered, use separated code + blocks for each. With many examples being presented, a clear separation helps + the reader to go directly to the good part. Consider offering an explanation + (for example, a comment, or a link to a resource) on why something is bad + practice. - Better and best cases can be considered part of the good case(s) code block. -In the same code block, precede each with comments: `# Better` and `# Best`. + In the same code block, precede each with comments: `# Better` and `# Best`. NOTE: **Note:** -While the bad-then-good approach is acceptable for the GitLab development guidelines, do not use it -for user documentation. For user documentation, use "Do" and "Don't." For example, see the -[Pajamas Design System](https://design.gitlab.com/content/punctuation/). +Although the bad-then-good approach is acceptable for the GitLab development +guidelines, do not use it for user documentation. For user documentation, use +*Do* and *Don't*. For examples, see the [Pajamas Design System](https://design.gitlab.com/content/punctuation/). diff --git a/doc/development/documentation/styleguide.md b/doc/development/documentation/styleguide.md index c252f6425d0..984c64b9e9e 100644 --- a/doc/development/documentation/styleguide.md +++ b/doc/development/documentation/styleguide.md @@ -1,69 +1,109 @@ --- +stage: none +group: Style Guide +info: To determine the technical writer assigned to the Stage/Group associated with this page, see https://about.gitlab.com/handbook/engineering/ux/technical-writing/#designated-technical-writers description: 'Writing styles, markup, formatting, and other standards for GitLab Documentation.' --- # Documentation Style Guide -This document defines the standards for GitLab's documentation content and files. +This document defines the standards for GitLab's documentation content and +files. For broader information about the documentation, see the [Documentation guidelines](index.md). -For programmatic help adhering to the guidelines, see [Testing](index.md#testing). +For guidelines specific to text in the GitLab interface, see the Pajamas [Content](https://design.gitlab.com/content/error-messages) section. -See the GitLab handbook for further [writing style guidelines](https://about.gitlab.com/handbook/communication/#writing-style-guidelines) -that apply to all GitLab content, not just documentation. +For information on how to validate styles locally or by using GitLab CI/CD, see [Testing](index.md#testing). -View [a list of recent style guide updates](https://gitlab.com/dashboard/merge_requests?scope=all&utf8=%E2%9C%93&state=merged&label_name[]=tw-style¬[label_name][]=docs%3A%3Afix). +Use this guide for standards on grammar, formatting, word usage, and more. + +You can also view a list of [recent updates to this guide](https://gitlab.com/dashboard/merge_requests?scope=all&utf8=%E2%9C%93&state=merged&label_name[]=tw-style¬[label_name][]=docs%3A%3Afix). + +If you can't find what you need: + +- View the GitLab Handbook for [writing style guidelines](https://about.gitlab.com/handbook/communication/#writing-style-guidelines) that apply to all GitLab content. +- Refer to one of the following: + + - [Microsoft Style Guide](https://docs.microsoft.com/en-us/style-guide/). + - [Google Developer Documentation Style Guide](https://developers.google.com/style). + +If you have questions about style, mention `@tw-style` in an issue or merge request, or, if you have access to the GitLab Slack workspace, use `#docs-process`. ## Documentation is the single source of truth (SSOT) ### Why a single source of truth -The documentation of GitLab products and features is the SSOT for all information related to implementation, usage, and troubleshooting. It evolves continuously, in keeping with new products and features, and with improvements for clarity, accuracy, and completeness. +The documentation of GitLab products and features is the SSOT for all +information related to implementation, usage, and troubleshooting. It evolves +continuously, in keeping with new products and features, and with improvements +for clarity, accuracy, and completeness. -This policy prevents information silos, making it easier to find information about GitLab products. +This policy prevents information silos, making it easier to find information +about GitLab products. -It also informs decisions about the kinds of content we include in our documentation. +It also informs decisions about the kinds of content we include in our +documentation. ### All information -Include problem-solving actions that may address rare cases or be considered 'risky', so long as proper context is provided in the form of fully detailed warnings and caveats. This kind of content should be included as it could be helpful to others and, when properly explained, its benefits outweigh the risks. If you think you have found an exception to this rule, contact the Technical Writing team. +Include problem-solving actions that may address rare cases or be considered +*risky*, so long as proper context is provided in the form of fully detailed +warnings and caveats. This kind of content should be included as it could be +helpful to others and, when properly explained, its benefits outweigh the risks. +If you think you have found an exception to this rule, contact the +Technical Writing team. -We will add all troubleshooting information to the documentation, no matter how unlikely a user is to encounter a situation. -For the [Troubleshooting sections](#troubleshooting), people in GitLab Support can merge additions themselves. +We will add all troubleshooting information to the documentation, no matter how +unlikely a user is to encounter a situation. For the [Troubleshooting sections](#troubleshooting), +people in GitLab Support can merge additions themselves. ### All media types -Include any media types/sources if the content is relevant to readers. You can freely include or link presentations, diagrams, videos, and so on; no matter who it was originally composed for, if it is helpful to any of our audiences, we can include it. +Include any media types/sources if the content is relevant to readers. You can +freely include or link presentations, diagrams, videos, and so on; no matter who +it was originally composed for, if it is helpful to any of our audiences, we can +include it. -- If you use an image that has a separate source file (for example, a vector or diagram format), link the image to the source file so that it may be reused or updated by anyone. -- Do not copy and paste content from other sources unless it is a limited quotation with the source cited. Typically it is better to either rephrase relevant information in your own words or link out to the other source. +- If you use an image that has a separate source file (for example, a vector or + diagram format), link the image to the source file so that it may be reused or + updated by anyone. +- Do not copy and paste content from other sources unless it is a limited + quotation with the source cited. Typically it is better to either rephrase + relevant information in your own words or link out to the other source. ### No special types -In the software industry, it is a best practice to organize documentation in different types. For example, [Divio recommends](https://www.divio.com/blog/documentation/): +In the software industry, it is a best practice to organize documentation in +different types. For example, [Divio recommends](https://www.divio.com/blog/documentation/): -1. Tutorials -1. How-to guides -1. Explanation -1. Reference (for example, a glossary) +- Tutorials +- How-to guides +- Explanation +- Reference (for example, a glossary) -At GitLab, we have so many product changes in our monthly releases that we can't afford to continuously update multiple types of information. -If we have multiple types, the information will become outdated. Therefore, we have a [single template](structure.md) for documentation. +At GitLab, we have so many product changes in our monthly releases that we can't +afford to continuously update multiple types of information. If we have multiple +types, the information will become outdated. Therefore, we have a +[single template](structure.md) for documentation. -We currently do not distinguish specific document types, although we are open to reconsidering this policy -once the documentation has reached a future stage of maturity and quality. If you are reading this, then despite our -continuous improvement efforts, that point hasn't been reached. +We currently do not distinguish specific document types, although we are open to +reconsidering this policy after the documentation has reached a future stage of +maturity and quality. If you are reading this, then despite our continuous +improvement efforts, that point hasn't been reached. ### Link instead of summarize -There is a temptation to summarize the information on another page. -This will cause the information to live in two places. -Instead, link to the SSOT and explain why it is important to consume the information. +There is a temptation to summarize the information on another page. This will +cause the information to live in two places. Instead, link to the single source +of truth and explain why it is important to consume the information. ### Organize by topic, not by type -Beyond top-level audience-type folders (for example, `administration`), we organize content by topic, not by type, so it can be located as easily as possible within the single-source-of-truth (SSOT) section for the subject matter. +Beyond top-level audience-type folders (for example, `administration`), we +organize content by topic, not by type, so it can be located as easily as +possible within the single-source-of-truth (SSOT) section for the subject +matter. For example, do not create groupings of similar media types. For example: @@ -71,46 +111,69 @@ For example, do not create groupings of similar media types. For example: - FAQs. - Sets of all articles or videos. -Such grouping of content by type makes -it difficult to browse for the information you need and difficult to maintain up-to-date content. -Instead, organize content by its subject (for example, everything related to CI goes together) -and cross-link between any related content. +Such grouping of content by type makes it difficult to browse for the information +you need and difficult to maintain up-to-date content. Instead, organize content +by its subject (for example, everything related to CI goes together) and +cross-link between any related content. ### Docs-first methodology -We employ a **docs-first methodology** to help ensure the docs remain a complete and trusted resource, and to make communicating about the use of GitLab more efficient. +We employ a *documentation-first methodology* to help ensure the documentation +remains a complete and trusted resource, and to make communicating about the use +of GitLab more efficient. -- If the answer to a question exists in documentation, share the link to the docs instead of rephrasing the information. -- When you encounter new information not available in GitLab’s documentation (for example, when working on a support case or testing a feature), your first step should be to create a merge request (MR) to add this information to the docs. You can then share the MR in order to communicate this information. +- If the answer to a question exists in documentation, share the link to the + documentation instead of rephrasing the information. +- When you encounter new information not available in GitLab’s documentation (for + example, when working on a support case or testing a feature), your first step + should be to create a merge request (MR) to add this information to the + documentation. You can then share the MR in order to communicate this + information. -New information that would be useful toward the future usage or troubleshooting of GitLab should not be written directly in a forum or other messaging system, but added to a docs MR and then referenced, as described above. Note that among any other doc changes, you can either: +New information that would be useful toward the future usage or troubleshooting +of GitLab should not be written directly in a forum or other messaging system, +but added to a documentation MR and then referenced, as described above. Note +that among any other documentation changes, you can either: - Add a [Troubleshooting section](#troubleshooting) to a doc if none exists. -- Un-comment and use the placeholder Troubleshooting section included as part of our [doc template](structure.md#template-for-new-docs), if present. +- Un-comment and use the placeholder Troubleshooting section included as part of + our [documentation template](structure.md#template-for-new-docs), if present. -The more we reflexively add useful information to the docs, the more (and more successfully) the docs will be used to efficiently accomplish tasks and solve problems. +The more we reflexively add useful information to the documentation, the more +(and more successfully) the documentation will be used to efficiently accomplish +tasks and solve problems. -If you have questions when considering, authoring, or editing docs, ask the Technical Writing team on Slack in `#docs` or in GitLab by mentioning the writer for the applicable [DevOps stage](https://about.gitlab.com/handbook/product/product-categories/#devops-stages). Otherwise, forge ahead with your best effort. It does not need to be perfect; the team is happy to review and improve upon your content. Please review the [Documentation guidelines](index.md) before you begin your first documentation MR. +If you have questions when considering, authoring, or editing documentation, ask +the Technical Writing team on Slack in `#docs` or in GitLab by mentioning the +writer for the applicable [DevOps stage](https://about.gitlab.com/handbook/product/product-categories/#devops-stages). +Otherwise, forge ahead with your best effort. It does not need to be perfect; +the team is happy to review and improve upon your content. Please review the +[Documentation guidelines](index.md) before you begin your first documentation MR. -Having a knowledge base in any form that is separate from the documentation would be against the docs-first methodology because the content would overlap with the documentation. +Having a knowledge base in any form that is separate from the documentation would +be against the documentation-first methodology because the content would overlap with +the documentation. ## Markdown All GitLab documentation is written using [Markdown](https://en.wikipedia.org/wiki/Markdown). -The [documentation website](https://docs.gitlab.com) uses GitLab Kramdown as its Markdown rendering engine. For a complete Kramdown reference, see the [GitLab Markdown Kramdown Guide](https://about.gitlab.com/handbook/markdown-guide/). +The [documentation website](https://docs.gitlab.com) uses GitLab Kramdown as its +Markdown rendering engine. For a complete Kramdown reference, see the +[GitLab Markdown Kramdown Guide](https://about.gitlab.com/handbook/markdown-guide/). -The [`gitlab-kramdown`](https://gitlab.com/gitlab-org/gitlab_kramdown) -Ruby gem will support all [GFM markup](../../user/markdown.md) in the future. That is, -all markup supported for display in the GitLab application itself. For now, -use regular Markdown markup, following the rules in the linked style guide. +The [`gitlab-kramdown`](https://gitlab.com/gitlab-org/gitlab_kramdown) Ruby gem +will support all [GFM markup](../../user/markdown.md) in the future. That is, +all markup supported for display in the GitLab application itself. For now, use +regular Markdown markup, following the rules in the linked style guide. -Note that Kramdown-specific markup (for example, `{:.class}`) will not render properly on GitLab instances under [`/help`](index.md#gitlab-help). +Note that Kramdown-specific markup (for example, `{:.class}`) will not render +properly on GitLab instances under [`/help`](index.md#gitlab-help). ### HTML in Markdown -Hard-coded HTML is valid, although it's discouraged from being used while we have `/help`. -HTML is permitted as long as: +Hard-coded HTML is valid, although it's discouraged from being used while we +have `/help`. HTML is permitted as long as: - There's no equivalent markup in Markdown. - Advanced tables are necessary. @@ -120,23 +183,23 @@ HTML is permitted as long as: ### Markdown Rules GitLab ensures that the Markdown used across all documentation is consistent, as -well as easy to review and maintain, by [testing documentation changes](index.md#testing) with -[markdownlint](index.md#markdownlint). This lint test fails when any document has an issue -with Markdown formatting that may cause the page to render incorrectly within GitLab. -It will also fail when a document is using non-standard Markdown (which may render -correctly, but is not the current standard for GitLab documentation). +well as easy to review and maintain, by [testing documentation changes](index.md#testing) +with [markdownlint](index.md#markdownlint). This lint test fails when any +document has an issue with Markdown formatting that may cause the page to render +incorrectly within GitLab. It will also fail when a document is using +non-standard Markdown (which may render correctly, but is not the current +standard for GitLab documentation). #### Markdown rule `MD044/proper-names` (capitalization) -A rule that could cause confusion is `MD044/proper-names`, as it might not be immediately -clear what caused markdownlint to fail, or how to correct the failure. This rule -checks a list of known words, listed in the `.markdownlint.json` file in each project, -to verify proper use of capitalization and backticks. Words in backticks will -be ignored by markdownlint. +A rule that could cause confusion is `MD044/proper-names`, as it might not be +immediately clear what caused markdownlint to fail, or how to correct the +failure. This rule checks a list of known words, listed in the `.markdownlint.json` +file in each project, to verify proper use of capitalization and backticks. +Words in backticks will be ignored by markdownlint. -In general, product names should follow the exact capitalization of the official names -of the products, protocols, and so on. -See [`.markdownlint.json`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/.markdownlint.json) +In general, product names should follow the exact capitalization of the official +names of the products, protocols, and so on. See [`.markdownlint.json`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/.markdownlint.json) for the words tested for proper capitalization in GitLab documentation. Some examples fail if incorrect capitalization is used: @@ -145,60 +208,66 @@ Some examples fail if incorrect capitalization is used: - NGINX (needs all capitals) - runit (needs lowercase `r`) -Additionally, commands, parameters, values, filenames, and so on must be included in backticks. -For example: +Additionally, commands, parameters, values, filenames, and so on must be +included in backticks. For example: - "Change the `needs` keyword in your `.gitlab.yml`..." - - `needs` is a parameter, and `.gitlab.yml` is a file, so both need backticks. Additionally, - `.gitlab.yml` will fail markdownlint without backticks as it does not have capital G or L. + - `needs` is a parameter, and `.gitlab.yml` is a file, so both need backticks. + Additionally, `.gitlab.yml` will fail markdownlint without backticks as it + does not have capital G or L. - "Run `git clone` to clone a Git repository..." - - `git clone` is a command, so it must be lowercase, while Git is the product, so - it must have a capital G. + - `git clone` is a command, so it must be lowercase, while Git is the product, + so it must have a capital G. ## Structure -Because we want documentation to be a SSOT, we should [organize by topic, not by type](#organize-by-topic-not-by-type). +Because we want documentation to be a SSOT, we should [organize by topic, not by +type](#organize-by-topic-not-by-type). ### Folder structure overview The documentation is separated by top-level audience folders [`user`](https://gitlab.com/gitlab-org/gitlab-foss/tree/master/doc/user), -[`administration`](https://gitlab.com/gitlab-org/gitlab-foss/tree/master/doc/administration), and [`development`](https://gitlab.com/gitlab-org/gitlab-foss/tree/master/doc/development) (contributing) folders. +[`administration`](https://gitlab.com/gitlab-org/gitlab-foss/tree/master/doc/administration), +and [`development`](https://gitlab.com/gitlab-org/gitlab-foss/tree/master/doc/development) +(contributing) folders. -Beyond that, we primarily follow the structure of the GitLab user interface or API. +Beyond that, we primarily follow the structure of the GitLab user interface or +API. -Our goal is to have a clear hierarchical structure with meaningful URLs -like `docs.gitlab.com/user/project/merge_requests/`. With this pattern, -you can immediately tell that you are navigating to user-related documentation -about Project features; specifically about Merge Requests. Our site's paths match +Our goal is to have a clear hierarchical structure with meaningful URLs like +`docs.gitlab.com/user/project/merge_requests/`. With this pattern, you can +immediately tell that you are navigating to user-related documentation about +Project features; specifically about Merge Requests. Our site's paths match those of our repository, so the clear structure also makes documentation easier to update. The table below shows what kind of documentation goes where. -| Directory | What belongs here | -|:----------------------|:---------------------------------------------------------------------------------------------------------------------------------| -| `doc/user/` | User related documentation. Anything that can be done within the GitLab UI goes here, including usage of the `/admin` interface. | +| Directory | What belongs here | +|:----------------------|:----------------------------------------------------------------------------------------------------------------------------------------| +| `doc/user/` | User related documentation. Anything that can be done within the GitLab user interface goes here, including usage of the `/admin` interface. | | `doc/administration/` | Documentation that requires the user to have access to the server where GitLab is installed. The admin settings that can be accessed via GitLab's interface exist under `doc/user/admin_area/`. | -| `doc/api/` | API related documentation. | -| `doc/development/` | Documentation related to the development of GitLab, whether contributing code or docs. Related process and style guides should go here. | -| `doc/legal/` | Legal documents about contributing to GitLab. | -| `doc/install/` | Contains instructions for installing GitLab. | -| `doc/update/` | Contains instructions for updating GitLab. | -| `doc/topics/` | Indexes per topic (`doc/topics/topic-name/index.md`): all resources for that topic. | +| `doc/api/` | API related documentation. | +| `doc/development/` | Documentation related to the development of GitLab, whether contributing code or documentation. Related process and style guides should go here. | +| `doc/legal/` | Legal documents about contributing to GitLab. | +| `doc/install/` | Contains instructions for installing GitLab. | +| `doc/update/` | Contains instructions for updating GitLab. | +| `doc/topics/` | Indexes per topic (`doc/topics/topic-name/index.md`): all resources for that topic. | ### Work with directories and files 1. When you create a new directory, always start with an `index.md` file. - Do not use another file name and **do not** create `README.md` files. -1. **Do not** use special characters and spaces, or capital letters in file names, - directory names, branch names, and anything that generates a path. -1. When creating a new document and it has more than one word in its name, - make sure to use underscores instead of spaces or dashes (`-`). For example, - a proper naming would be `import_projects_from_github.md`. The same rule - applies to images. + Do not use another file name and *do not* create `README.md` files. +1. *Do not* use special characters and spaces, or capital letters in file + names, directory names, branch names, and anything that generates a path. +1. When creating or renaming a file or directory and it has more than one word + in its name, use underscores (`_`) instead of spaces or dashes. For example, + proper naming would be `import_project/import_from_github.md`. This applies + to both image files and Markdown files. 1. For image files, do not exceed 100KB. 1. Do not upload video files to the product repositories. [Link or embed videos](#videos) instead. -1. There are four main directories, `user`, `administration`, `api` and `development`. +1. There are four main directories: `user`, `administration`, `api`, and + `development`. 1. The `doc/user/` directory has five main subdirectories: `project/`, `group/`, `profile/`, `dashboard/` and `admin_area/`. 1. `doc/user/project/` should contain all project related documentation. @@ -216,34 +285,43 @@ The table below shows what kind of documentation goes where. the **Visibility and Access Controls** category should have a document located at `doc/user/admin_area/settings/visibility_and_access_controls.md`. 1. The `doc/topics/` directory holds topic-related technical content. Create - `doc/topics/topic-name/subtopic-name/index.md` when subtopics become necessary. + `doc/topics/topic_name/subtopic_name/index.md` when subtopics become necessary. General user- and admin- related documentation, should be placed accordingly. -1. The directories `/workflow/`, `/university/`, and `/articles/` have - been **deprecated** and the majority their docs have been moved to their correct location - in small iterations. +1. The directories `/workflow/`, `/university/`, and `/articles/` have been + *deprecated* and the majority their documentation has been moved to their + correct location in small iterations. -If you are unsure where a document or a content addition should live, this should +If you are unsure where to place a document or a content addition, this should not stop you from authoring and contributing. You can use your best judgment and -then ask the reviewer of your MR to confirm your decision, and/or ask a technical writer -at any stage in the process. The technical writing team will review all documentation -changes, regardless, and can move content if there is a better place for it. +then ask the reviewer of your MR to confirm your decision, and/or ask a +technical writer at any stage in the process. The technical writing team will +review all documentation changes, regardless, and can move content if there is a +better place for it. ### Avoid duplication -Do not include the same information in multiple places. [Link to a SSOT instead.](#link-instead-of-summarize) +Do not include the same information in multiple places. +[Link to a single source of truth instead.](#link-instead-of-summarize) ### References across documents -- Give each folder an index.md page that introduces the topic, introduces the pages within, and links to the pages within (including to the index pages of any next-level subpaths). -- To ensure discoverability, ensure each new or renamed doc is linked from its higher-level index page and other related pages. -- When making reference to other GitLab products and features, link to their respective docs, at least on first mention. -- When making reference to third-party products or technologies, link out to their external sites, documentation, and resources. +- Give each folder an `index.md` page that introduces the topic, introduces the + pages within, and links to the pages within (including to the index pages of + any next-level subpaths). +- To ensure discoverability, ensure each new or renamed doc is linked from its + higher-level index page and other related pages. +- When making reference to other GitLab products and features, link to their + respective documentation, at least on first mention. +- When making reference to third-party products or technologies, link out to + their external sites, documentation, and resources. ### Structure within documents -- Include any and all applicable subsections as described on the [structure and template](structure.md) page. -- Structure content in alphabetical order in tables, lists, and so on, unless there is - a logical reason not to (for example, when mirroring the UI or an otherwise ordered sequence). +- Include any and all applicable subsections as described on the + [structure and template](structure.md) page. +- Structure content in alphabetical order in tables, lists, and so on, unless + there's a logical reason not to (for example, when mirroring the user + interface or an otherwise ordered sequence). ## Language @@ -255,9 +333,9 @@ GitLab documentation should be clear and easy to understand. ### Point of view -In most cases, it’s appropriate to use the second-person (you, yours) point of view, -because it’s friendly and easy to understand. -(Tested in [`FirstPerson.yml`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/doc/.vale/gitlab/FirstPerson.yml).) +In most cases, it’s appropriate to use the second-person (you, yours) point of +view, because it’s friendly and easy to understand. (Tested in +[`FirstPerson.yml`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/doc/.vale/gitlab/FirstPerson.yml).) <!-- How do we harmonize the second person in Pajamas with our first person plural in our doc guide? --> @@ -272,16 +350,18 @@ Use sentence case. For example: #### UI text -When referring to specific user interface text, like a button label or menu item, use the same capitalization that is displayed in the UI. -Standards for this content are listed in the [Pajamas Design System Content section](https://design.gitlab.com/content/punctuation/) and typically -match what is called for in this Documentation Style Guide. +When referring to specific user interface text, like a button label or menu +item, use the same capitalization that is displayed in the user interface. +Standards for this content are listed in the [Pajamas Design System Content section](https://design.gitlab.com/content/punctuation/) +and typically match what is called for in this Documentation Style Guide. -If you think there is a mistake in the way the UI text is styled, -create an issue or an MR to propose a change to the UI text. +If you think there is a mistake in the way the user interface text is styled, +create an issue or an MR to propose a change to the user interface text. #### Feature names -- **Feature names are typically lowercase**, like those describing actions and types of objects in GitLab. For example: +- *Feature names are typically lowercase*, like those describing actions and + types of objects in GitLab. For example: - epics - issues - issue weights @@ -289,7 +369,9 @@ create an issue or an MR to propose a change to the UI text. - milestones - reorder issues - runner, runners, shared runners -- **Some features are capitalized**, typically nouns naming GitLab-specific capabilities or tools. For example: + - a to-do, to-dos +- *Some features are capitalized*, typically nouns naming GitLab-specific + capabilities or tools. For example: - GitLab CI/CD - Repository Mirroring - Value Stream Analytics @@ -298,48 +380,67 @@ create an issue or an MR to propose a change to the UI text. - Geo - GitLab Runner (see [this issue](https://gitlab.com/gitlab-org/gitlab/-/issues/233529) for details) -Document any exceptions in this style guide. If you're not sure, ask a GitLab Technical Writer so that they can help decide and document the result. +Document any exceptions in this style guide. If you're not sure, ask a GitLab +Technical Writer so that they can help decide and document the result. -Do not match the capitalization of terms or phrases on the [Features page](https://about.gitlab.com/features/) or [features.yml](https://gitlab.com/gitlab-com/www-gitlab-com/blob/master/data/features.yml) by default. +Do not match the capitalization of terms or phrases on the [Features page](https://about.gitlab.com/features/) +or [features.yml](https://gitlab.com/gitlab-com/www-gitlab-com/blob/master/data/features.yml) +by default. #### Other terms Capitalize names of: -- GitLab [product tiers](https://about.gitlab.com/pricing/). For example, GitLab Core - and GitLab Ultimate. (Tested in [`BadgeCapitalization.yml`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/doc/.vale/gitlab/BadgeCapitalization.yml).) -- Third-party organizations, software, and products. For example, Prometheus, Kubernetes, Git, and The Linux Foundation. -- Methods or methodologies. For example, Continuous Integration, Continuous Deployment, Scrum, and Agile. (Tested in [`.markdownlint.json`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/.markdownlint.json).) +- GitLab [product tiers](https://about.gitlab.com/pricing/). For example, + GitLab Core and GitLab Ultimate. (Tested in [`BadgeCapitalization.yml`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/doc/.vale/gitlab/BadgeCapitalization.yml).) +- Third-party organizations, software, and products. For example, Prometheus, + Kubernetes, Git, and The Linux Foundation. +- Methods or methodologies. For example, Continuous Integration, + Continuous Deployment, Scrum, and Agile. (Tested in [`.markdownlint.json`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/.markdownlint.json).) + +Follow the capitalization style listed at the [authoritative source](#links-to-external-documentation) +for the entity, which may use non-standard case styles. For example: GitLab and +npm. -Follow the capitalization style listed at the [authoritative source](#links-to-external-documentation) for the entity, which may use non-standard case styles. For example: GitLab and npm. +Use forms of *sign in*, instead of *log in* or *login*. For example: + +- Sign in to GitLab. +- Open the sign-in page. + +Exceptions to this rule include the concept of *single sign-on* and +references to user interface elements. For example: + +- To sign in to product X, enter your credentials, and then click **Log in**. ### Inclusive language -We strive to create documentation that is inclusive. This section includes guidance and examples in the -following categories: +We strive to create documentation that is inclusive. This section includes +guidance and examples in the following categories: - [Gender-specific wording](#avoid-gender-specific-wording). - [Ableist language](#avoid-ableist-language). - [Cultural sensitivity](#culturally-sensitive-language). -We write our developer documentation with inclusivity and diversity in mind. This page is not an exhaustive reference, but describes some general guidelines and examples that illustrate some best practices to follow. +We write our developer documentation with inclusivity and diversity in mind. This +page is not an exhaustive reference, but describes some general guidelines and +examples that illustrate some best practices to follow. #### Avoid gender-specific wording When possible, use gender-neutral pronouns. For example, you can use a singular -[they](https://developers.google.com/style/pronouns#gender-neutral-pronouns) as a gender-neutral -pronoun. +[they](https://developers.google.com/style/pronouns#gender-neutral-pronouns) as +a gender-neutral pronoun. Avoid the use of gender-specific pronouns, unless referring to a specific person. -| Use | Avoid | -|-----------------------------------|-----------------| -| People, humanity | Mankind | -| GitLab Team Members | Manpower | +| Use | Avoid | +|-----------------------------------|---------------------------------| +| People, humanity | Mankind | +| GitLab Team Members | Manpower | | You can install; They can install | He can install; She can install | -If you need to set up [Fake user information](#fake-user-information), use diverse or non-gendered -names with common surnames. +If you need to set up [Fake user information](#fake-user-information), use +diverse or non-gendered names with common surnames. #### Avoid ableist language @@ -354,11 +455,14 @@ Avoid terms that are also used in negative stereotypes for different groups. | Active/Inactive | Enabled/Disabled | | On/Off | Enabled/Disabled | -Credit: [Avoid ableist language](https://developers.google.com/style/inclusive-documentation#ableist-language) in the Google Developer Style Guide. +Credit: [Avoid ableist language](https://developers.google.com/style/inclusive-documentation#ableist-language) +in the Google Developer Style Guide. #### Culturally sensitive language -Avoid terms that reflect negative cultural stereotypes and history. In most cases, you can replace terms such as `master` and `slave` with terms that are more precise and functional, such as `primary` and `secondary`. +Avoid terms that reflect negative cultural stereotypes and history. In most +cases, you can replace terms such as `master` and `slave` with terms that are +more precise and functional, such as `primary` and `secondary`. | Use | Avoid | |----------------------|-----------------------| @@ -372,8 +476,10 @@ For more information see the following [Internet Draft specification](https://to When creating documentation, limit or avoid the use of the following verb tenses, words, and phrases: -- Avoid jargon when possible, and when not possible, define the term or [link to a definition](#links-to-external-documentation). -- Avoid uncommon words when a more-common alternative is possible, ensuring that content is accessible to more readers. +- Avoid jargon when possible, and when not possible, define the term or + [link to a definition](#links-to-external-documentation). +- Avoid uncommon words when a more-common alternative is possible, ensuring that + content is accessible to more readers. - Don't write in the first person singular. (Tested in [`FirstPerson.yml`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/doc/.vale/gitlab/FirstPerson.yml).) - Instead of "I" or "me," use "we," "you," "us," or "one." @@ -403,7 +509,7 @@ tenses, words, and phrases: - Instead of "e.g.," use "for example," "such as," "for instance," or "like." - Instead of "etc.," either use "and so on" or consider editing it out, since it can be vague. - <!-- vale gitlab.rulename = NO --> + <!-- vale gitlab.LatinTerms = YES --> - Avoid using the word *currently* when talking about the product or its features. The documentation describes the product as it is, and not as it will be at some indeterminate point in the future. @@ -435,64 +541,46 @@ tenses, words, and phrases: ### Contractions -- Use common contractions when it helps create a friendly and informal tone, especially in tutorials, instructional documentation, and [UIs](https://design.gitlab.com/content/punctuation/#contractions). (Tested in [`Contractions.yml`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/doc/.vale/gitlab/Contractions.yml).) - - | Do | Don't | - |----------|-----------| - | it's | it is | - | can't | cannot | - | wouldn't | would not | - | you're | you are | - | you've | you have | - | haven't | have not | - | don't | do not | - | we're | we are | - | that's | that is | - | won't | will not | - -- Avoid less common contractions: - - | Do | Don't | - |--------------|-------------| - | he would | he'd | - | it will | it'll | - | should have | should've | - | there would | there'd | +Contractions are encouraged, and can create a friendly and informal tone, +especially in tutorials, instructional documentation, and +[user interfaces](https://design.gitlab.com/content/punctuation/#contractions). + +Some contractions, however, should be avoided: - Do not use contractions with a proper noun and a verb. For example: - | Do | Don't | - |----------------------|---------------------| - | GitLab is creating X | GitLab's creating X | + | Do | Don't | + |------------------------------------------|-----------------------------------------| + | GitLab is creating X. | GitLab's creating X. | - Do not use contractions when you need to emphasize a negative. For example: - | Do | Don't | - |-----------------------------|----------------------------| - | Do **not** install X with Y | **Don't** install X with Y | + | Do | Don't | + |------------------------------------------|-----------------------------------------| + | Do *not* install X with Y. | *Don't* install X with Y. | - Do not use contractions in reference documentation. For example: - | Do | Don't | - |------------------------------------------|----------------------------| - | Do **not** set a limit greater than 1000 | **Don't** set a limit greater than 1000 | - | For `parameter1`, the default is 10 | For `parameter1`, the default's 10 | + | Do | Don't | + |------------------------------------------|-----------------------------------------| + | Do *not* set a limit greater than 1000. | *Don't* set a limit greater than 1000. | + | For `parameter1`, the default is 10. | For `parameter1`, the default's 10. | - Avoid contractions in error messages. Examples: - | Do | Don't | - |------------------------------------------|----------------------------| - | Requests to localhost are not allowed | Requests to localhost aren't allowed | - | Specified URL cannot be used | Specified URL can't be used | - -<!-- vale on --> + | Do | Don't | + |------------------------------------------|-----------------------------------------| + | Requests to localhost are not allowed. | Requests to localhost aren't allowed. | + | Specified URL cannot be used. | Specified URL can't be used. | ## Text - [Write in Markdown](#markdown). -- Splitting long lines (preferably up to 100 characters) can make it easier to provide feedback on small chunks of text. +- Splitting long lines (preferably up to 100 characters) can make it easier to + provide feedback on small chunks of text. - Insert an empty line for new paragraphs. -- Insert an empty line between different markups (for example, after every paragraph, header, list, and so on). Example: +- Insert an empty line between different markups (for example, after every + paragraph, header, list, and so on). Example: ```markdown ## Header @@ -511,27 +599,27 @@ tenses, words, and phrases: ### Punctuation -Check the general punctuation rules for the GitLab documentation on the table below. -Check specific punctuation rules for [lists](#lists) below. +Review the general punctuation rules for the GitLab documentation in the +following table. Check specific punctuation rules for [lists](#lists) below. Additional examples are available in the [Pajamas guide for punctuation](https://design.gitlab.com/content/punctuation/). -| Rule | Example | -| ---- | ------- | -| Always end full sentences with a period. | _For a complete overview, read through this document._| +| Rule | Example | +|------------------------------------------------------------------|--------------------------------------------------------| +| Always end full sentences with a period. | _For a complete overview, read through this document._ | | Always add a space after a period when beginning a new sentence. | _For a complete overview, check this doc. For other references, check out this guide._ | | Do not use double spaces. (Tested in [`SentenceSpacing.yml`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/doc/.vale/gitlab/SentenceSpacing.yml).) | --- | | Do not use tabs for indentation. Use spaces instead. You can configure your code editor to output spaces instead of tabs when pressing the tab key. | --- | | Use serial commas ("Oxford commas") before the final 'and/or' in a list. (Tested in [`OxfordComma.yml`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/doc/.vale/gitlab/OxfordComma.yml).) | _You can create new issues, merge requests, and milestones._ | | Always add a space before and after dashes when using it in a sentence (for replacing a comma, for example). | _You should try this - or not._ | -| Always use lowercase after a colon. | _Related Issues: a way to create a relationship between issues._ | +| Always use lowercase after a colon. | _Related Issues: a way to create a relationship between issues._ | ### Placeholder text -Often in examples, a writer will provide a command or configuration that is complete apart from -a value specific to the reader. +Often in examples, a writer will provide a command or configuration that +uses values specific to the reader. -In these cases, use [`<` and `>`](https://en.wikipedia.org/wiki/Usage_message#Pattern) to call out -where a reader must replace text with their own value. +In these cases, use [`<` and `>`](https://en.wikipedia.org/wiki/Usage_message#Pattern) +to call out where a reader must replace text with their own value. For example: @@ -539,10 +627,22 @@ For example: cp <your_source_directory> <your_destination_directory> ``` +### Keyboard commands + +Use the HTML `<kbd>` tag when referring to keystroke presses. For example: + +```plaintext +To stop the command, press <kbd>Ctrl</kbd>+<kbd>C</kbd>. +``` + +When the docs are generated, the output is: + +To stop the command, press <kbd>Ctrl</kbd>+<kbd>C</kbd>. + ## Lists -- Always start list items with a capital letter, unless they are parameters or commands - that are in backticks, or similar. +- Always start list items with a capital letter, unless they are parameters or + commands that are in backticks, or similar. - Always leave a blank line before and after a list. - Begin a line with spaces (not tabs) to denote a [nested sub-item](#nesting-inside-a-list-item). @@ -573,19 +673,19 @@ This is a list of available features: ### Markup - Use dashes (`-`) for unordered lists instead of asterisks (`*`). -- Prefix `1.` to every item in an ordered list. - When rendered, the list items will appear with sequential numbering automatically. +- Prefix `1.` to every item in an ordered list. When rendered, the list items + will appear with sequential numbering automatically. ### Punctuation - Do not add commas (`,`) or semicolons (`;`) to the end of list items. -- Only add periods to the end of a list item if the item consists of a complete sentence. - The [definition of full sentence](https://www2.le.ac.uk/offices/ld/all-resources/writing/grammar/grammar-guides/sentence) +- Only add periods to the end of a list item if the item consists of a complete + sentence. The [definition of full sentence](https://www2.le.ac.uk/offices/ld/all-resources/writing/grammar/grammar-guides/sentence) is: _"a complete sentence always contains a verb, expresses a complete idea, and makes sense standing alone"_. -- Be consistent throughout the list: if the majority of the items do not end in a period, - do not end any of the items in a period, even if they consist of a complete sentence. - The opposite is also valid: if the majority of the items end with a period, end - all with a period. +- Be consistent throughout the list: if the majority of the items do not end in + a period, do not end any of the items in a period, even if they consist of a + complete sentence. The opposite is also valid: if the majority of the items + end with a period, end all with a period. - Separate list items from explanatory text with a colon (`:`). For example: ```markdown @@ -623,16 +723,17 @@ Don't (vary use of periods; majority rules): ### Nesting inside a list item -It is possible to nest items under a list item, so that they render with the same indentation -as the list item. This can be done with: +It's possible to nest items under a list item, so that they render with the same +indentation as the list item. This can be done with: - [Code blocks](#code-blocks) - [Blockquotes](#blockquotes) - [Alert boxes](#alert-boxes) - [Images](#images) -Items nested in lists should always align with the first character of the list item. -In unordered lists (using `-`), this means two spaces for each level of indentation: +Items nested in lists should always align with the first character of the list +item. In unordered lists (using `-`), this means two spaces for each level of +indentation: ````markdown - Unordered list item 1 @@ -678,8 +779,9 @@ For ordered lists, use three spaces for each level of indentation:  ```` -You can nest full lists inside other lists using the same rules as above. If you wish -to mix types, that is also possible, as long as you don't mix items at the same level: +You can nest full lists inside other lists using the same rules as above. If you +want to mix types, that is also possible, as long as you don't mix items at the +same level: ```markdown 1. Ordered list item one. @@ -737,8 +839,10 @@ page), use the following phrases (based on the SVG icons): Valid for Markdown content only, not for front matter entries: -- Standard quotes: double quotes (`"`). Example: "This is wrapped in double quotes". -- Quote within a quote: double quotes (`"`) wrap single quotes (`'`). Example: "I am 'quoting' something within a quote". +- Standard quotes: double quotes (`"`). Example: "This is wrapped in double + quotes". +- Quote within a quote: double quotes (`"`) wrap single quotes (`'`). Example: + "I am 'quoting' something within a quote". For other punctuation rules, please refer to the [GitLab UX guide](https://design.gitlab.com/content/punctuation/). @@ -755,58 +859,66 @@ For other punctuation rules, please refer to the someone in the Merge Request. - [Avoid using symbols and special characters](https://gitlab.com/gitlab-org/gitlab-docs/-/issues/84) in headers. Whenever possible, they should be plain and short text. -- Avoid adding things that show ephemeral statuses. For example, if a feature is - considered beta or experimental, put this information in a note, not in the heading. +- When possible, avoid including words that might change in the future. Changing + a heading changes its anchor URL, which affects other linked pages. - When introducing a new document, be careful for the headings to be grammatically and syntactically correct. Mention an [assigned technical writer (TW)](https://about.gitlab.com/handbook/product/product-categories/) for review. - This is to ensure that no document with wrong heading is going - live without an audit, thus preventing dead links and redirection issues when - corrected. + This is to ensure that no document with wrong heading is going live without an + audit, thus preventing dead links and redirection issues when corrected. - Leave exactly one blank line before and after a heading. - Do not use links in headings. -- Add the corresponding [product badge](#product-badges) according to the tier the feature belongs. -- Our docs site search engine prioritizes words used in headings and subheadings. - Make you subheading titles clear, descriptive, and complete to help users find the - right example, as shown in the section on [heading titles](#heading-titles). +- Add the corresponding [product badge](#product-badges) according to the tier the + feature belongs. +- Our documentation site search engine prioritizes words used in headings and + subheadings. Make you subheading titles clear, descriptive, and complete to help + users find the right example, as shown in the section on [heading titles](#heading-titles). - See [Capitalization](#capitalization) for guidelines on capitalizing headings. ### Heading titles -Keep heading titles clear and direct. Make every word count. To accommodate search engine optimization (SEO), use the imperative, where possible. +Keep heading titles clear and direct. Make every word count. To accommodate +search engine optimization (SEO), use the imperative, where possible. -| Do | Don't | -|:-----|:--------| -| Configure GDK | Configuring GDK | +| Do | Don't | +|:--------------------------------------|:------------------------------------------------------------| +| Configure GDK | Configuring GDK | | GitLab Release and Maintenance Policy | This section covers GitLab's Release and Maintenance Policy | -| Backport to older releases | Backporting to older releases | -| GitLab Pages examples | Examples | +| Backport to older releases | Backporting to older releases | +| GitLab Pages examples | Examples | For guidelines on capitalizing headings, see the section on [capitalization](#capitalization). NOTE: **Note:** -If you change an existing title, be careful. Any such changes may affect not only [links](#anchor-links) -within the page, but may also affect links from GitLab itself, as well as external links, to GitLab documentation. +If you change an existing title, be careful. Any such changes may affect not +only [links](#anchor-links) within the page, but may also affect links to the +GitLab documentation from both the GitLab application and external sites. ### Anchor links Headings generate anchor links automatically when rendered. `## This is an example` generates the anchor `#this-is-an-example`. -Keep in mind that the GitLab UI links to a large number of docs and respective -anchor links to take the user to the right spot. Therefore, when you change a -heading, search `doc/*`, `app/views/*`, and `ee/app/views/*` for the old anchor -to make sure you're not breaking an anchor linked from other docs nor from the -GitLab UI. If you find the old anchor, make sure to replace it with the new one. +NOTE: **Note:** +[Introduced](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/39717) in GitLab 13.4, [product badges](#product-badges) used in headings aren't included in the +generated anchor links. For example, when you link to +`## This is an example **(CORE)**`, use the anchor `#this-is-an-example`. + +Keep in mind that the GitLab user interface links to many documentation pages +and anchor links to take the user to the right spot. Therefore, when you change +a heading, search `doc/*`, `app/views/*`, and `ee/app/views/*` for the old +anchor to make sure you're not breaking an anchor linked from other +documentation nor from the GitLab user interface. If you find the old anchor, be +sure to replace it with the new one. Important: -- Avoid crosslinking docs to headings unless you need to link to a specific section - of the document. This will avoid breaking anchors in the future in case the heading - is changed. +- Avoid crosslinking documentation to headings unless you need to link to a + specific section of the document. This will avoid breaking anchors in the + future in case the heading is changed. - If possible, avoid changing headings since they're not only linked internally. - There are various links to GitLab documentation on the internet, such as tutorials, - presentations, StackOverflow posts, and other sources. + There are various links to GitLab documentation on the internet, such as + tutorials, presentations, StackOverflow posts, and other sources. - Do not link to `h1` headings. Note that, with Kramdown, it is possible to add a custom ID to an HTML element @@ -815,16 +927,20 @@ do not use this option until further notice. ## Links -Links are important in GitLab documentation. They allow you to [link instead of summarizing](#link-instead-of-summarize) -to help preserve an [SSoT](#why-a-single-source-of-truth) within GitLab documentation. +Links are important in GitLab documentation. They allow you to [link instead of +summarizing](#link-instead-of-summarize) to help preserve a [single source of truth](#why-a-single-source-of-truth) +within GitLab documentation. We include guidance for links in the following categories: - How to set up [anchor links](#anchor-links) for headings. - How to set up [criteria](#basic-link-criteria) for configuring a link. -- What to set up when [linking to a `help`](../documentation/index.md#linking-to-help) page. -- How to set up [links to internal documentation](#links-to-internal-documentation) for cross-references. -- How to set up [links to external documentation](#links-to-external-documentation) for authoritative sources. +- What to set up when [linking to a `help`](../documentation/index.md#linking-to-help) + page. +- How to set up [links to internal documentation](#links-to-internal-documentation) + for cross-references. +- How to set up [links to external documentation](#links-to-external-documentation) + for authoritative sources. - When to use [links requiring permissions](#links-requiring-permissions). - How to set up a [link to a video](#link-to-video). - How to [include links with version text](#text-for-documentation-requiring-version-text). @@ -833,7 +949,7 @@ We include guidance for links in the following categories: ### Basic link criteria - Use inline link Markdown markup `[Text](https://example.com)`. - It's easier to read, review, and maintain. **Do not** use `[Text][identifier]`. + It's easier to read, review, and maintain. *Do not* use `[Text][identifier]`. - Use [meaningful anchor texts](https://www.futurehosting.com/blog/links-should-have-meaningful-anchor-text-heres-why/). For example, instead of writing something like `Read more about GitLab Issue Boards [here](LINK)`, @@ -842,18 +958,23 @@ We include guidance for links in the following categories: ### Links to internal documentation NOTE: **Note:** -_Internal_ refers to documentation in the same project. When linking to documentation in -separate projects (for example, linking to Omnibus docs from GitLab docs), you must use absolute -URLs. +_Internal_ refers to documentation in the same project. When linking to +documentation in separate projects (for example, linking to Omnibus documentation +from GitLab documentation), you must use absolute URLs. -Do not use absolute URLs like `https://docs.gitlab.com/ee/index.html` to crosslink -to other docs within the same project. Use relative links to the file, like `../index.md`. (These are converted to HTML when the site is rendered.) +Do not use absolute URLs like `https://docs.gitlab.com/ee/index.html` to +crosslink to other documentation within the same project. Use relative links to +the file, like `../index.md`. (These are converted to HTML when the site is +rendered.) Relative linking enables crosslinks to work: - in Review Apps, local previews, and `/help`. -- when working on the docs locally, so you can verify that they work as early as possible in the process. -- within the GitLab UI when browsing doc files in their respective repositories. For example, the links displayed at `https://gitlab.com/gitlab-org/gitlab/-/blob/master/doc/README.md`. +- when working on the documentation locally, so you can verify that they work as + early as possible in the process. +- within the GitLab user interface when browsing doc files in their respective + repositories. For example, the links displayed at + `https://gitlab.com/gitlab-org/gitlab/-/blob/master/doc/README.md`. To link to internal documentation: @@ -869,7 +990,8 @@ To link to internal documentation: Do: `../../geo/replication/troubleshooting.md` -- Always add the file name `file.md` at the end of the link with the `.md` extension, not `.html`. +- Always add the file name `file.md` at the end of the link with the `.md` + extension, not `.html`. Don't: @@ -884,28 +1006,32 @@ To link to internal documentation: - `../../issues/tags.md#stages` NOTE: **Note:** -Using the Markdown extension is necessary for the [`/help`](index.md#gitlab-help) section of GitLab. +Using the Markdown extension is necessary for the [`/help`](index.md#gitlab-help) +section of GitLab. ### Links to external documentation -When describing interactions with external software, it's often helpful to include links to external -documentation. When possible, make sure that you're linking to an [**authoritative** source](#authoritative-sources). -For example, if you're describing a feature in Microsoft's Active Directory, include a link to official Microsoft documentation. +When describing interactions with external software, it's often helpful to +include links to external documentation. When possible, make sure that you're +linking to an [**authoritative** source](#authoritative-sources). For example, +if you're describing a feature in Microsoft's Active Directory, include a link +to official Microsoft documentation. ### Authoritative sources -When citing external information, use sources that are written by the people who created -the item or product in question. These sources are the most likely to -be accurate and remain up to date. +When citing external information, use sources that are written by the people who +created the item or product in question. These sources are the most likely to be +accurate and remain up to date. Examples of authoritative sources include: -- Specifications, such as a [Request for Comments](https://www.ietf.org/standards/rfcs/) document -from the Internet Engineering Task Force. -- Official documentation for a product. For example, if you're setting up an interface with the -Google OAuth 2 authorization server, include a link to Google's documentation. -- Official documentation for a project. For example, if you're citing NodeJS functionality, -refer directly to [NodeJS documentation](https://nodejs.org/en/docs/). +- Specifications, such as a [Request for Comments](https://www.ietf.org/standards/rfcs/) + document from the Internet Engineering Task Force. +- Official documentation for a product. For example, if you're setting up an + interface with the Google OAuth 2 authorization server, include a link to + Google's documentation. +- Official documentation for a project. For example, if you're citing NodeJS + functionality, refer directly to [NodeJS documentation](https://nodejs.org/en/docs/). - Books from an authoritative publisher. Examples of sources to avoid include: @@ -916,19 +1042,22 @@ Examples of sources to avoid include: - Discussions on forums such as Stack Overflow. - Documentation from a company that describes another company's product. -While many of these sources to avoid can help you learn skills and or features, they can become -obsolete quickly. Nobody is obliged to maintain any of these sites. Therefore, we should avoid using them as reference literature. +While many of these sources to avoid can help you learn skills and or features, +they can become obsolete quickly. Nobody is obliged to maintain any of these +sites. Therefore, we should avoid using them as reference literature. NOTE: **Note:** -Non-authoritative sources are acceptable only if there is no equivalent authoritative source. -Even then, focus on non-authoritative sources that are extensively cited or peer-reviewed. +Non-authoritative sources are acceptable only if there is no equivalent +authoritative source. Even then, focus on non-authoritative sources that are +extensively cited or peer-reviewed. ### Links requiring permissions Don't link directly to: - [Confidential issues](../../user/project/issues/confidential_issues.md). -- Project features that require [special permissions](../../user/permissions.md) to view. +- Project features that require [special permissions](../../user/permissions.md) + to view. These will fail for: @@ -940,7 +1069,8 @@ Instead: - To reduce confusion, mention in the text that the information is either: - Contained in a confidential issue. - Requires special permission to a project to view. -- Provide a link in back ticks (`` ` ``) so that those with access to the issue can easily navigate to it. +- Provide a link in back ticks (`` ` ``) so that those with access to the issue + can easily navigate to it. Example: @@ -950,54 +1080,54 @@ For more information, see the [confidential issue](../../user/project/issues/con ### Link to specific lines of code -When linking to specific lines within a file, link to a commit instead of to the branch. -Lines of code change through time, therefore, linking to a line by using the commit link -ensures the user lands on the line you're referring to. The **Permalink** button, which is -available when viewing a file within a project, makes it easy to generate a link to the -most recent commit of the given file. +When linking to specific lines within a file, link to a commit instead of to the +branch. Lines of code change through time, therefore, linking to a line by using +the commit link ensures the user lands on the line you're referring to. The +**Permalink** button, which is available when viewing a file within a project, +makes it easy to generate a link to the most recent commit of the given file. -- **Do:** `[link to line 3](https://gitlab.com/gitlab-org/gitlab/-/blob/11f17c56d8b7f0b752562d78a4298a3a95b5ce66/.gitlab/issue_templates/Feature%20proposal.md#L3)` -- **Don't:** `[link to line 3](https://gitlab.com/gitlab-org/gitlab/-/blob/master/.gitlab/issue_templates/Feature%20proposal.md#L3).` +- *Do:* `[link to line 3](https://gitlab.com/gitlab-org/gitlab/-/blob/11f17c56d8b7f0b752562d78a4298a3a95b5ce66/.gitlab/issue_templates/Feature%20proposal.md#L3)` +- *Don't:* `[link to line 3](https://gitlab.com/gitlab-org/gitlab/-/blob/master/.gitlab/issue_templates/Feature%20proposal.md#L3).` -If that linked expression is no longer in that line of the file due to further commits, you -can still search the file for that query. In this case, update the document to ensure it -links to the most recent version of the file. +If that linked expression is no longer in that line of the file due to additional +commits, you can still search the file for that query. In this case, update the +document to ensure it links to the most recent version of the file. ## Navigation -To indicate the steps of navigation through the UI: +To indicate the steps of navigation through the user interface: - Use the exact word as shown in the UI, including any capital letters as-is. -- Use bold text for navigation items and the char "greater than" (`>`) as separator - (for example, `Navigate to your project's **Settings > CI/CD**` ). -- If there are any expandable menus, make sure to mention that the user - needs to expand the tab to find the settings you're referring to (for example, `Navigate to your project's **Settings > CI/CD** and expand **General pipelines**`). +- Use bold text for navigation items and the char "greater than" (`>`) as a + separator (for example, `Navigate to your project's **Settings > CI/CD**` ). +- If there are any expandable menus, make sure to mention that the user needs to + expand the tab to find the settings you're referring to (for example, + `Navigate to your project's **Settings > CI/CD** and expand **General pipelines**`). ## Images Images, including screenshots, can help a reader better understand a concept. However, they can be hard to maintain, and should be used sparingly. -Before including an image in the documentation, ensure it provides value to the reader. +Before including an image in the documentation, ensure it provides value to the +reader. ### Capture the image -Use images to help the reader understand where they are in a process, or how they need to -interact with the application. +Use images to help the reader understand where they are in a process, or how +they need to interact with the application. When you take screenshots: - *Capture the most relevant area of the page.* Don't include unnecessary white - space or areas of the page that don't help illustrate your point. Also, don't - include the entire page if you don't have to, but also ensure the image - contains enough information to allow the user to determine where things are. -- *Be consistent.* Find a browser window size that works for you that also - displays all areas of the product, including the left navigation (usually > - 1200px wide). For consistency, use this browser window size for your - screenshots by installing a browser extension for setting a window to a - specific size (for example, - [Window Resizer](https://chrome.google.com/webstore/detail/window-resizer/kkelicaakdanhinjdeammmilcgefonfh/related?hl=en) - for Google Chrome). + space or areas of the page that don't help illustrate the point. The left + sidebar of the GitLab user interface can change, so don't include the sidebar + if it's not necessary. +- *Keep it small.* If you don't need to show the full width of the screen, don't. + A value of 1000 pixels is a good maximum width for your screenshot image. +- *Be consistent.* Coordinate screenshots with the other screenshots already on + a documentation page. For example, if other screenshots include the left + sidebar, include the sidebar in all screenshots. ### Save the image @@ -1017,15 +1147,16 @@ When you take screenshots: - Images should be used (only when necessary) to _illustrate_ the description of a process, not to _replace_ it. - Max image size: 100KB (gifs included). -- See also how to link and embed [videos](#videos) to illustrate the docs. +- See also how to link and embed [videos](#videos) to illustrate the + documentation. ### Add the image link to content The Markdown code for including an image in a document is: `` -The image description is the alt text for the rendered image on the docs site. -For accessibility and SEO, use [descriptions](https://webaim.org/techniques/alttext/) +The image description is the alt text for the rendered image on the +documentation site. For accessibility and SEO, use [descriptions](https://webaim.org/techniques/alttext/) that: - Are accurate, succinct, and unique. @@ -1036,9 +1167,9 @@ Also, if a heading immediately follows an image, be sure to add three dashes ### Remove image shadow -All images displayed on the [GitLab Docs site](https://docs.gitlab.com) have a box shadow by default. -To remove the box shadow, use the image class `.image-noshadow` applied -directly to an HTML `img` tag: +All images displayed on the [GitLab documentation site](https://docs.gitlab.com) +have a box shadow by default. To remove the box shadow, use the image class +`.image-noshadow` applied directly to an HTML `img` tag: ```html <img src="path/to/image.jpg" alt="Alt text (required)" class="image-noshadow"> @@ -1075,18 +1206,20 @@ request. ## Videos -Adding GitLab's existing YouTube video tutorials to the documentation is -highly encouraged, unless the video is outdated. Videos should not -replace documentation, but complement or illustrate it. If content in a video is -fundamental to a feature and its key use cases, but this is not adequately covered in the documentation, -add this detail to the documentation text or create an issue to review the video and do so. +Adding GitLab's existing YouTube video tutorials to the documentation is highly +encouraged, unless the video is outdated. Videos should not replace +documentation, but complement or illustrate it. If content in a video is +fundamental to a feature and its key use cases, but this is not adequately +covered in the documentation, add this detail to the documentation text or +create an issue to review the video and do so. -Do not upload videos to the product repositories. [Link](#link-to-video) or [embed](#embed-videos) them instead. +Do not upload videos to the product repositories. [Link](#link-to-video) or +[embed](#embed-videos) them instead. ### Link to video -To link out to a video, include a YouTube icon so that readers can -quickly and easily scan the page for videos before reading: +To link out to a video, include a YouTube icon so that readers can scan the page +for videos before reading: ```markdown <i class="fa fa-youtube-play youtube" aria-hidden="true"></i> @@ -1099,26 +1232,24 @@ You can link any up-to-date video that is useful to the GitLab user. > [Introduced](https://gitlab.com/gitlab-org/gitlab-docs/-/merge_requests/472) in GitLab 12.1. -The [GitLab Docs site](https://docs.gitlab.com) supports embedded videos. +The [GitLab documentation site](https://docs.gitlab.com) supports embedded +videos. -You can only embed videos from -[GitLab's official YouTube account](https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg). +You can only embed videos from [GitLab's official YouTube account](https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg). For videos from other sources, [link](#link-to-video) them instead. -In most cases, it is better to [link to video](#link-to-video) instead, -because an embed takes up a lot of space on the page and can be distracting -to readers. +In most cases, it is better to [link to video](#link-to-video) instead, because +an embed takes up a lot of space on the page and can be distracting to readers. -To embed a video, follow the instructions below and make sure -you have your MR reviewed and approved by a technical writer. +To embed a video, follow the instructions below and make sure you have your MR +reviewed and approved by a technical writer. -1. Copy the code below and paste it into your Markdown file. - Leave a blank line above and below it. Do NOT edit the code - (don't remove or add any spaces). -1. On YouTube, visit the video URL you want to display. Copy - the regular URL from your browser (`https://www.youtube.com/watch?v=VIDEO-ID`) - and replace the video title and link in the line under `<div class="video-fallback">`. -1. On YouTube, click **Share**, then **Embed**. +1. Copy the code below and paste it into your Markdown file. Leave a blank line + above and below it. Do *not* edit the code (don't remove or add any spaces). +1. In YouTube, visit the video URL you want to display. Copy the regular URL + from your browser (`https://www.youtube.com/watch?v=VIDEO-ID`) and replace + the video title and link in the line under `<div class="video-fallback">`. +1. In YouTube, click **Share**, and then click **Embed**. 1. Copy the `<iframe>` source (`src`) **URL only** (`https://www.youtube.com/embed/VIDEO-ID`), and paste it, replacing the content of the `src` field in the @@ -1135,7 +1266,7 @@ leave a blank line here leave a blank line here ``` -This is how it renders on the GitLab Docs site: +This is how it renders on the GitLab documentation site: <div class="video-fallback"> See the video: <a href="https://www.youtube.com/watch?v=enMumwvLAug">What is GitLab</a>. @@ -1147,26 +1278,28 @@ This is how it renders on the GitLab Docs site: > Notes: > > - The `figure` tag is required for semantic SEO and the `video_container` -class is necessary to make sure the video is responsive and displays -nicely on different mobile devices. +class is necessary to make sure the video is responsive and displays on +different mobile devices. > - The `<div class="video-fallback">` is a fallback necessary for GitLab's -`/help`, as GitLab's Markdown processor does not support iframes. It's hidden on the docs site but will be displayed on GitLab's `/help`. +`/help`, as GitLab's Markdown processor does not support iframes. It's hidden on +the documentation site, but will be displayed on GitLab's `/help`. ## Code blocks - Always wrap code added to a sentence in inline code blocks (`` ` ``). For example, `.gitlab-ci.yml`, `git add .`, `CODEOWNERS`, or `only: [master]`. - File names, commands, entries, and anything that refers to code should be added to code blocks. - To make things easier for the user, always add a full code block for things that can be - useful to copy and paste, as they can easily do it with the button on code blocks. + File names, commands, entries, and anything that refers to code should be + added to code blocks. To make things easier for the user, always add a full + code block for things that can be useful to copy and paste, as they can easily + do it with the button on code blocks. - Add a blank line above and below code blocks. -- When providing a shell command and its output, prefix the shell command with `$` and - leave a blank line between the command and the output. +- When providing a shell command and its output, prefix the shell command with `$` + and leave a blank line between the command and the output. - When providing a command without output, don't prefix the shell command with `$`. - If you need to include triple backticks inside a code block, use four backticks for the codeblock fences instead of three. -- For regular fenced code blocks, always use a highlighting class corresponding to the - language for better readability. Examples: +- For regular fenced code blocks, always use a highlighting class corresponding to + the language for better readability. Examples: ````markdown ```ruby @@ -1186,10 +1319,10 @@ nicely on different mobile devices. ``` ```` -Syntax highlighting is required for fenced code blocks added to the GitLab documentation. -Refer to the table below for the most common language classes, or check the -[complete list](https://github.com/rouge-ruby/rouge/wiki/List-of-supported-languages-and-lexers) -of language classes available. +Syntax highlighting is required for fenced code blocks added to the GitLab +documentation. Refer to the following table for the most common language classes, +or check the [complete list](https://github.com/rouge-ruby/rouge/wiki/List-of-supported-languages-and-lexers) +of available language classes: | Preferred language tags | Language aliases and notes | |-------------------------|------------------------------------------------------------------------------| @@ -1220,16 +1353,17 @@ of language classes available. | `xml` | | | `yaml` | Alias: `yml`. | -For a complete reference on code blocks, check the [Kramdown guide](https://about.gitlab.com/handbook/markdown-guide/#code-blocks). +For a complete reference on code blocks, see the [Kramdown guide](https://about.gitlab.com/handbook/markdown-guide/#code-blocks). ## GitLab SVG icons > [Introduced](https://gitlab.com/gitlab-org/gitlab-docs/-/issues/384) in GitLab 12.7. -You can use icons from the [GitLab SVG library](https://gitlab-org.gitlab.io/gitlab-svgs/) directly -in the documentation. +You can use icons from the [GitLab SVG library](https://gitlab-org.gitlab.io/gitlab-svgs/) +directly in the documentation. -This way, you can achieve a consistent look when writing about interacting with GitLab UI elements. +This way, you can achieve a consistent look when writing about interacting with +GitLab user interface elements. Usage examples: @@ -1243,7 +1377,7 @@ Usage examples: Example: `**{tanuki, 24}**` renders as: **{tanuki, 24}**. - Icon with custom size and class: `**{icon-name, size, class-name}**`. - You can access any class available to this element in GitLab docs CSS. + You can access any class available to this element in GitLab documentation CSS. Example with `float-right`, a [Bootstrap utility class](https://getbootstrap.com/docs/4.4/utilities/float/): @@ -1251,8 +1385,8 @@ Usage examples: ### When to use icons -Icons should be used sparingly, and only in ways that aid and do not hinder the readability of the -text. +Icons should be used sparingly, and only in ways that aid and do not hinder the +readability of the text. For example, the following adds little to the accompanying text: @@ -1262,54 +1396,68 @@ For example, the following adds little to the accompanying text: 1. Go to **{home}** **Project overview > Details** -However, the following might help the reader connect the text to the user interface: +However, the following might help the reader connect the text to the user +interface: ```markdown | Section | Description | |:-------------------------|:----------------------------------------------------------------------------------------------------------------------------| -| **{overview}** Overview | View your GitLab Dashboard, and administer projects, users, groups, jobs, Runners, and Gitaly servers. | +| **{overview}** Overview | View your GitLab Dashboard, and administer projects, users, groups, jobs, runners, and Gitaly servers. | | **{monitor}** Monitoring | View GitLab system information, and information on background jobs, logs, health checks, requests profiles, and audit logs. | | **{messages}** Messages | Send and manage broadcast messages for your users. | ``` | Section | Description | |:-------------------------|:----------------------------------------------------------------------------------------------------------------------------| -| **{overview}** Overview | View your GitLab Dashboard, and administer projects, users, groups, jobs, Runners, and Gitaly servers. | +| **{overview}** Overview | View your GitLab Dashboard, and administer projects, users, groups, jobs, runners, and Gitaly servers. | | **{monitor}** Monitoring | View GitLab system information, and information on background jobs, logs, health checks, requests profiles, and audit logs. | | **{messages}** Messages | Send and manage broadcast messages for your users. | -Use an icon when you find youself having to describe an interface element. For example: +Use an icon when you find yourself having to describe an interface element. For +example: - Do: Click the Admin Area icon ( **{admin}** ). - Don't: Click the Admin Area icon (the wrench icon). ## Alert boxes -Whenever you need to call special attention to particular sentences, -use the following markup for highlighting. +When you need to call special attention to particular sentences, use the +following markup to create highlighted alert boxes. Note that the alert boxes only work for one paragraph only. Multiple paragraphs, -lists, headers and so on, will not render correctly. For multiple lines, use [blockquotes](#blockquotes) instead. +lists, headers and so on, will not render correctly. For multiple lines, use +[blockquotes](#blockquotes) instead. -Alert boxes only render on the GitLab Docs site (<https://docs.gitlab.com>). +Alert boxes render only on the GitLab documentation site (<https://docs.gitlab.com>). Within GitLab itself, they will appear as plain Markdown text (like the examples above the rendered versions, below). +These alert boxes are used in the GitLab documentation. These aren't strict +guidelines, but for consistency you should try to use these values: + +| Color | Markup | Default keyword | Alternative keywords | +|--------|------------|-----------------|----------------------------------------------------------------------| +| Blue | `NOTE:` | `**Note:**` | | +| Yellow | `CAUTION:` | `**Caution:**` | `**Warning:**`, `**Important:**` | +| Red | `DANGER:` | `**Danger:**` | `**Warning:**`, `**Important:**`, `**Deprecated:**`, `**Required:**` | +| Green | `TIP:` | `**Tip:**` | | + ### Note Notes catch the eye of most readers, and therefore should be used very sparingly. In most cases, content considered for a note should be included: -- As just another sentence in the previous paragraph or the most-relevant paragraph. +- As just another sentence in the previous paragraph or the most-relevant + paragraph. - As its own standalone paragraph. -- As content under a new subheading that introduces the topic, making it more visible/findable. +- As content under a new subheading that introduces the topic, making it more + visible or findable. #### When to use Use a note when there is a reason that most or all readers who browse the -section should see the content. That is, if missed, it’s likely to cause -major trouble for a minority of users or significant trouble for a majority -of users. +section should see the content. That is, if missed, it’s likely to cause major +trouble for a minority of users or significant trouble for a majority of users. Weigh the costs of distracting users to whom the content is not relevant against the cost of users missing the content if it were not expressed as a note. @@ -1319,7 +1467,7 @@ NOTE: **Note:** This is something to note. ``` -How it renders on the GitLab Docs site: +How it renders on the GitLab documentation site: NOTE: **Note:** This is something to note. @@ -1331,7 +1479,7 @@ TIP: **Tip:** This is a tip. ``` -How it renders on the GitLab Docs site: +How it renders on the GitLab documentation site: TIP: **Tip:** This is a tip. @@ -1343,7 +1491,7 @@ CAUTION: **Caution:** This is something to be cautious about. ``` -How it renders on the GitLab Docs site: +How it renders on the GitLab documentation site: CAUTION: **Caution:** This is something to be cautious about. @@ -1355,7 +1503,7 @@ DANGER: **Danger:** This is a breaking change, a bug, or something very important to note. ``` -How it renders on the GitLab Docs site: +How it renders on the GitLab documentation site: DANGER: **Danger:** This is a breaking change, a bug, or something very important to note. @@ -1368,7 +1516,7 @@ For highlighting a text within a blue blockquote, use this format: > This is a blockquote. ``` -which renders on the [GitLab Docs site](https://docs.gitlab.com) as: +which renders on the [GitLab documentation site](https://docs.gitlab.com) as: > This is a blockquote. @@ -1396,19 +1544,22 @@ Which renders to: ## Terms -To maintain consistency through GitLab documentation, the following guides documentation authors -on agreed styles and usage of terms. +To maintain consistency through GitLab documentation, the following guides +documentation authors on agreed styles and usage of terms. ### Merge requests (MRs) -Merge requests allow you to exchange changes you made to source code and collaborate -with other people on the same project. You'll see this term used in the following ways: +Merge requests allow you to exchange changes you made to source code and +collaborate with other people on the same project. You'll see this term used in +the following ways: -- Use lowercase **merge requests** regardless of whether referring to the feature or individual merge requests. +- Use lowercase *merge requests* regardless of whether referring to the feature + or individual merge requests. As noted in the GitLab [Writing Style Guidelines](https://about.gitlab.com/handbook/communication/#writing-style-guidelines), if you use the **MR** acronym, expand it at least once per document page. -Typically, the first use would be phrased as _merge request (MR)_ with subsequent instances being _MR_. +Typically, the first use would be phrased as _merge request (MR)_ with subsequent +instances being _MR_. Examples: @@ -1418,14 +1569,18 @@ Examples: ### Describe UI elements -The following are styles to follow when describing UI elements on a screen: +The following are styles to follow when describing user interface elements in an +application: -- For elements with a visible label, use that label in bold with matching case. For example, `the **Cancel** button`. -- For elements with a tooltip or hover label, use that label in bold with matching case. For example, `the **Add status emoji** button`. +- For elements with a visible label, use that label in bold with matching case. + For example, `the **Cancel** button`. +- For elements with a tooltip or hover label, use that label in bold with + matching case. For example, `the **Add status emoji** button`. ### Verbs for UI elements -The following are recommended verbs for specific uses with UI elements: +The following are recommended verbs for specific uses with user interface +elements: | Recommended | Used for | Replaces | |:--------------------|:---------------------------|:---------------------------| @@ -1447,22 +1602,26 @@ Tagged and released versions of GitLab documentation are available: - In the [documentation archives](https://docs.gitlab.com/archives/). - At the `/help` URL for any GitLab installation. -The version introducing a new feature is added to the top of the topic in the documentation to provide -a helpful link back to how the feature was developed. +The version introducing a new feature is added to the top of the topic in the +documentation to provide a link back to how the feature was developed. TIP: **Tip:** -Whenever you have documentation related to the `gitlab.rb` file, you're working with a self-managed installation. -The section or page is therefore likely to apply only to self-managed instances. -If so, the relevant "`TIER` ONLY" [Product badge](#product-badges) should be included at the highest applicable heading level. +Whenever you have documentation related to the `gitlab.rb` file, you're working +with a self-managed installation. The section or page is therefore likely to +apply only to self-managed instances. If so, the relevant "`TIER` ONLY" +[Product badge](#product-badges) should be included at the highest applicable +heading level. ### Text for documentation requiring version text -- For features that need to declare the GitLab version that the feature was introduced. Text similar - to the following should be added immediately below the heading as a blockquote: +- For features that need to declare the GitLab version that the feature was + introduced. Text similar to the following should be added immediately below + the heading as a blockquote: - `> Introduced in GitLab 11.3.`. -- Whenever possible, version text should have a link to the _completed_ issue, merge request, or epic that introduced the feature. - An issue is preferred over a merge request, and a merge request is preferred over an epic. For example: +- Whenever possible, version text should have a link to the _completed_ issue, + merge request, or epic that introduced the feature. An issue is preferred over + a merge request, and a merge request is preferred over an epic. For example: - `> [Introduced](<link-to-issue>) in GitLab 11.3.`. - If the feature is only available in GitLab Enterprise Edition, mention @@ -1470,8 +1629,8 @@ If so, the relevant "`TIER` ONLY" [Product badge](#product-badges) should be inc the feature is available in: - `> [Introduced](<link-to-issue>) in [GitLab Starter](https://about.gitlab.com/pricing/) 11.3.`. -- If listing information for multiple version as a feature evolves, add the information to a - block-quoted bullet list. For example: +- If listing information for multiple version as a feature evolves, add the + information to a block-quoted bullet list. For example: ```markdown > - [Introduced](<link-to-issue>) in GitLab 11.3. @@ -1492,25 +1651,28 @@ If so, the relevant "`TIER` ONLY" [Product badge](#product-badges) should be inc > - [Deprecated](<link-to-issue>) in GitLab 11.3. Replaced by [meaningful text](<link-to-appropriate-documentation>). ``` - It's also acceptable to describe the replacement in surrounding text, if available. + It's also acceptable to describe the replacement in surrounding text, if + available. - If the deprecation is not obvious in existing text, you may want to include a warning such as: + If the deprecation is not obvious in existing text, you may want to include a + warning such as: ```markdown - CAUTION: **Warning:** + DANGER: **Deprecated:** This feature was [deprecated](link-to-issue) in GitLab 12.3 and replaced by [Feature name](link-to-feature-documentation). ``` NOTE: **Note:** -Version text must be on its own line and surrounded by blank lines to render correctly. +Version text must be on its own line and surrounded by blank lines to render +correctly. ### Versions in the past or future When describing functionality available in past or future versions, use: -- **Earlier**, and not **older** or **before**. -- **Later**, and not **newer** or **after**. +- *Earlier*, and not *older* or *before*. +- *Later*, and not *newer* or *after*. For example: @@ -1522,33 +1684,34 @@ For example: ### Importance of referencing GitLab versions and tiers Mentioning GitLab versions and tiers is important to all users and contributors -to quickly have access to the issue or merge request that -introduced the change for reference. Also, they can easily understand what -features they have in their GitLab instance and version, given that the note has -some key information. +to quickly have access to the issue or merge request that introduced the change +for reference. Also, they can easily understand what features they have in their +GitLab instance and version, given that the note has some key information. `[Introduced](link-to-issue) in [GitLab Premium](https://about.gitlab.com/pricing/) 12.7` links to the issue that introduced the feature, says which GitLab tier it belongs to, says the GitLab version that it became available in, and links to -the pricing page in case the user wants to upgrade to a paid tier -to use that feature. +the pricing page in case the user wants to upgrade to a paid tier to use that +feature. -For example, if you're a regular user and you're looking at the docs for a feature you haven't used before, -you can immediately see if that feature is available to you or not. Alternatively, -if you've been using a certain feature for a long time and it changed in some way, -it's important -to be able to spot when it changed and what's new in that feature. +For example, if you're a regular user and you're looking at the documentation +for a feature you haven't used before, you can immediately see if that feature +is available to you or not. Alternatively, if you've been using a certain +feature for a long time and it changed in some way, it's important to be able to +determine when it changed and what's new in that feature. -This is even more important as we don't have a perfect process for shipping docs. -Unfortunately, we still see features without docs and docs without -features. So, for now, we cannot rely 100% on the docs site versions. +This is even more important as we don't have a perfect process for shipping +documentation. Unfortunately, we still see features without documentation, and +documentation without features. So, for now, we cannot rely 100% on the +documentation site versions. Over time, version text will reference a progressively older version of GitLab. In cases where version text refers to versions of GitLab four or more major versions back, you can consider removing the text if it's irrelevant or confusing. -For example, if the current major version is 12.x, version text referencing versions of GitLab 8.x -and older are candidates for removal if necessary for clearer or cleaner docs. +For example, if the current major version is 12.x, version text referencing +versions of GitLab 8.x and older are candidates for removal if necessary for +clearer or cleaner documentation. ## Products and features @@ -1598,21 +1761,21 @@ header or other page element according to the feature's availability: | *Only* GitLab.com Silver and higher tiers (no self-managed instances) | `**(SILVER ONLY)**` | | *Only* GitLab.com Gold (no self-managed instances) | `**(GOLD ONLY)**` | -For clarity, all page title headers (H1s) must be have a tier markup for -the lowest tier that has information on the documentation page. +For clarity, all page title headers (H1s) must be have a tier markup for the +lowest tier that has information on the documentation page. If sections of a page apply to higher tier levels, they can be separately labeled with their own tier markup. #### Product badge display behavior -When using the tier markup with headers, the documentation page will -display the full tier badge with the header line. +When using the tier markup with headers, the documentation page will display the +full tier badge with the header line. -You can also use the tier markup with paragraphs, list items, -and table cells. For these cases, the tier mention will be represented by an -orange info icon **{information}** that will display the tiers when visitors -point to the icon. For example: +You can also use the tier markup with paragraphs, list items, and table cells. +For these cases, the tier mention will be represented by an orange info icon +**{information}** that will display the tiers when visitors point to the icon. +For example: - `**(STARTER)**` displays as **(STARTER)** - `**(STARTER ONLY)**` displays as **(STARTER ONLY)** @@ -1623,16 +1786,17 @@ point to the icon. For example: Introduced by [!244](https://gitlab.com/gitlab-org/gitlab-docs/-/merge_requests/244), the special markup `**(STARTER)**` will generate a `span` element to trigger the badges and tooltips (`<span class="badge-trigger starter">`). When the keyword -"only" is added, the corresponding GitLab.com badge will not be displayed. +*only* is added, the corresponding GitLab.com badge will not be displayed. ## Specific sections -Certain styles should be applied to specific sections. Styles for specific sections are outlined below. +Certain styles should be applied to specific sections. Styles for specific +sections are outlined below. ### GitLab restart -There are many cases that a restart/reconfigure of GitLab is required. To -avoid duplication, link to the special document that can be found in +There are many cases that a restart/reconfigure of GitLab is required. To avoid +duplication, link to the special document that can be found in [`doc/administration/restart_gitlab.md`](../../administration/restart_gitlab.md). Usually the text will read like: @@ -1643,8 +1807,8 @@ for the changes to take effect. If the document you are editing resides in a place other than the GitLab CE/EE `doc/` directory, instead of the relative link, use the full path: -`https://docs.gitlab.com/ce/administration/restart_gitlab.html`. -Replace `reconfigure` with `restart` where appropriate. +`https://docs.gitlab.com/ce/administration/restart_gitlab.html`. Replace +`reconfigure` with `restart` where appropriate. ### Installation guide @@ -1652,8 +1816,8 @@ Replace `reconfigure` with `restart` where appropriate. In [step 2 of the installation guide](../../install/installation.md#2-ruby), we install Ruby from source. Whenever there is a new version that needs to be updated, remember to change it throughout the codeblock and also replace -the sha256sum (it can be found in the [downloads page](https://www.ruby-lang.org/en/downloads/) of the Ruby -website). +the sha256sum (it can be found in the [downloads page](https://www.ruby-lang.org/en/downloads/) +of the Ruby website). ### Configuration documentation for source and Omnibus installations @@ -1661,7 +1825,7 @@ GitLab currently officially supports two installation methods: installations from source and Omnibus packages installations. Whenever there is a setting that is configurable for both installation methods, -prefer to document it in the CE docs to avoid duplication. +prefer to document it in the CE documentation to avoid duplication. Configuration settings include: @@ -1681,7 +1845,8 @@ the style below as a guide: external_url "https://gitlab.example.com" ``` -1. Save the file and [reconfigure](path/to/administration/restart_gitlab.md#omnibus-gitlab-reconfigure) GitLab for the changes to take effect. +1. Save the file and [reconfigure](path/to/administration/restart_gitlab.md#omnibus-gitlab-reconfigure) + GitLab for the changes to take effect. --- @@ -1694,18 +1859,20 @@ the style below as a guide: host: "gitlab.example.com" ``` -1. Save the file and [restart](path/to/administration/restart_gitlab.md#installations-from-source) GitLab for the changes to take effect. +1. Save the file and [restart](path/to/administration/restart_gitlab.md#installations-from-source) + GitLab for the changes to take effect. ```` In this case: - Before each step list the installation method is declared in bold. -- Three dashes (`---`) are used to create a horizontal line and separate the - two methods. +- Three dashes (`---`) are used to create a horizontal line and separate the two + methods. - The code blocks are indented one or more spaces under the list item to render correctly. - Different highlighting languages are used for each config in the code block. -- The [GitLab Restart](#gitlab-restart) section is used to explain a required restart/reconfigure of GitLab. +- The [GitLab Restart](#gitlab-restart) section is used to explain a required + restart or reconfigure of GitLab. ### Troubleshooting @@ -1717,19 +1884,30 @@ can facilitate this by making sure the troubleshooting content addresses: 1. How the user can confirm they have the problem. 1. Steps the user can take towards resolution of the problem. -If the contents of each category can be summarized in one line and a list of steps aren't required, consider setting up a -[table](#tables) with headers of *Problem* \| *Cause* \| *Solution* (or *Workaround* if the fix is temporary), or *Error message* \| *Solution*. +If the contents of each category can be summarized in one line and a list of +steps aren't required, consider setting up a [table](#tables) with headers of +*Problem* \| *Cause* \| *Solution* (or *Workaround* if the fix is temporary), or +*Error message* \| *Solution*. ## Feature flags -Learn how to [document features deployed behind flags](feature_flags.md). -For guidance on developing GitLab with feature flags, see -[Feature flags in development of GitLab](../feature_flags/index.md). +Learn how to [document features deployed behind flags](feature_flags.md). For +guidance on developing GitLab with feature flags, see [Feature flags in development of GitLab](../feature_flags/index.md). ## RESTful API -Here is a list of must-have items for RESTful API documentation. Use them in the -exact order that appears on this document. Further explanation is given below. +REST API resources are documented in Markdown under +[`/doc/api`](https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/api). Each +resource has its own Markdown file, which is linked from `api_resources.md`. + +When modifying the Markdown, also update the corresponding +[OpenAPI definition](https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/api/openapi) +if one exists for the resource. If not, consider creating one. Match the latest +[OpenAPI 3.0.x specification](https://swagger.io/specification/). (For more +information, see the discussion in this +[issue](https://gitlab.com/gitlab-org/gitlab/-/issues/16023#note_370901810).) + +In the Markdown doc for a resource (AKA endpoint): - Every method must have the REST API request. For example: @@ -1737,8 +1915,7 @@ exact order that appears on this document. Further explanation is given below. GET /projects/:id/repository/branches ``` -- Every method must have a detailed - [description of the parameters](#method-description). +- Every method must have a detailed [description of the parameters](#method-description). - Every method must have a cURL example. - Every method must have a response body (in JSON format). @@ -1763,7 +1940,7 @@ METHOD /endpoint Example request: ```shell -curl --header "PRIVATE-TOKEN: <your_access_token>" 'https://gitlab.example.com/api/v4/endpoint?parameters' +curl --header "PRIVATE-TOKEN: <your_access_token>" "https://gitlab.example.com/api/v4/endpoint?parameters" ``` Example response: @@ -1782,8 +1959,9 @@ You may need to demonstrate an API call or a cURL command that includes the name and email address of a user. Don't use real user information in API calls: - **Email addresses**: Use an email address ending in `example.com`. -- **Names**: Use strings like `Example Username`. Alternatively, use diverse or non-gendered names with - common surnames, such as `Sidney Jones`, `Zhang Wei`. or `Maria Garcia`. +- **Names**: Use strings like `Example Username`. Alternatively, use diverse or + non-gendered names with common surnames, such as `Sidney Jones`, `Zhang Wei`, + or `Maria Garcia`. ### Fake URLs @@ -1795,11 +1973,10 @@ When including sample URLs in the documentation, use: ### Fake tokens There may be times where a token is needed to demonstrate an API call using -cURL or a variable used in CI. It is strongly advised not to use real -tokens in documentation even if the probability of a token being exploited is -low. +cURL or a variable used in CI. It is strongly advised not to use real tokens in +documentation even if the probability of a token being exploited is low. -You can use the following fake tokens as examples. +You can use the following fake tokens as examples: | Token type | Token value | |:----------------------|:-------------------------------------------------------------------| @@ -1808,8 +1985,8 @@ You can use the following fake tokens as examples. | Application ID | `2fcb195768c39e9a94cec2c2e32c59c0aad7a3365c10892e8116b5d83d4096b6` | | Application secret | `04f294d1eaca42b8692017b426d53bbc8fe75f827734f0260710b83a556082df` | | CI/CD variable | `Li8j-mLUVA3eZYjPfd_H` | -| Specific Runner token | `yrnZW46BrtBFqM7xDzE7dddd` | -| Shared Runner token | `6Vk7ZsosqQyfreAxXTZr` | +| Specific runner token | `yrnZW46BrtBFqM7xDzE7dddd` | +| Shared runner token | `6Vk7ZsosqQyfreAxXTZr` | | Trigger token | `be20d8dcc028677c931e04f3871a9b` | | Webhook secret token | `6XhDroRcYPM5by_h-HLY` | | Health check token | `Tu7BgjR9qeZTEyRzGG2P` | @@ -1850,14 +2027,15 @@ Rendered example: ### cURL Examples -Below is a set of [cURL](https://curl.haxx.se) examples that you can use in the API documentation. +The following sections include a set of [cURL](https://curl.haxx.se) examples +you can use in the API documentation. #### Simple cURL command Get the details of a group: ```shell -curl --header "PRIVATE-TOKEN: <your_access_token>" https://gitlab.example.com/api/v4/groups/gitlab-org +curl --header "PRIVATE-TOKEN: <your_access_token>" "https://gitlab.example.com/api/v4/groups/gitlab-org" ``` #### cURL example with parameters passed in the URL @@ -1870,9 +2048,9 @@ curl --request POST --header "PRIVATE-TOKEN: <your_access_token>" "https://gitla #### Post data using cURL's `--data` -Instead of using `--request POST` and appending the parameters to the URI, you can use -cURL's `--data` option. The example below will create a new project `foo` under -the authenticated user's namespace. +Instead of using `--request POST` and appending the parameters to the URI, you +can use cURL's `--data` option. The example below will create a new project +`foo` under the authenticated user's namespace. ```shell curl --data "name=foo" --header "PRIVATE-TOKEN: <your_access_token>" "https://gitlab.example.com/api/v4/projects" @@ -1881,11 +2059,11 @@ curl --data "name=foo" --header "PRIVATE-TOKEN: <your_access_token>" "https://gi #### Post data using JSON content NOTE: **Note:** -In this example we create a new group. Watch carefully the single -and double quotes. +In this example we create a new group. Watch carefully the single and double +quotes. ```shell -curl --request POST --header "PRIVATE-TOKEN: <your_access_token>" --header "Content-Type: application/json" --data '{"path": "my-group", "name": "My group"}' https://gitlab.example.com/api/v4/groups +curl --request POST --header "PRIVATE-TOKEN: <your_access_token>" --header "Content-Type: application/json" --data '{"path": "my-group", "name": "My group"}' "https://gitlab.example.com/api/v4/groups" ``` #### Post data using form-data @@ -1894,7 +2072,7 @@ Instead of using JSON or urlencode you can use multipart/form-data which properly handles data encoding: ```shell -curl --request POST --header "PRIVATE-TOKEN: <your_access_token>" --form "title=ssh-key" --form "key=ssh-rsa AAAAB3NzaC1yc2EA..." https://gitlab.example.com/api/v4/users/25/keys +curl --request POST --header "PRIVATE-TOKEN: <your_access_token>" --form "title=ssh-key" --form "key=ssh-rsa AAAAB3NzaC1yc2EA..." "https://gitlab.example.com/api/v4/users/25/keys" ``` The above example is run by and administrator and will add an SSH public key @@ -1916,41 +2094,47 @@ Use `%2F` for slashes (`/`). #### Pass arrays to API calls The GitLab API sometimes accepts arrays of strings or integers. For example, to -exclude specific users when requesting a list of users for a project, you would do something like this: +exclude specific users when requesting a list of users for a project, you would +do something like this: ```shell -curl --request PUT --header "PRIVATE-TOKEN: <your_access_token>" --data "skip_users[]=<user_id>" --data "skip_users[]=<user_id>" https://gitlab.example.com/api/v4/projects/<project_id>/users +curl --request PUT --header "PRIVATE-TOKEN: <your_access_token>" --data "skip_users[]=<user_id>" --data "skip_users[]=<user_id>" "https://gitlab.example.com/api/v4/projects/<project_id>/users" ``` ## GraphQL API -GraphQL APIs are different from [RESTful APIs](#restful-api). Reference information is -generated automatically in our [GraphQL reference](../../api/graphql/reference/index.md). +GraphQL APIs are different from [RESTful APIs](#restful-api). Reference +information is generated in our [GraphQL reference](../../api/graphql/reference/index.md). -However, it's helpful to include examples on how to use GraphQL for different "use cases", -with samples that readers can use directly in the [GraphiQL explorer](../api_graphql_styleguide.md#graphiql). +However, it's helpful to include examples on how to use GraphQL for different +*use cases*, with samples that readers can use directly in the +[GraphiQL explorer](../api_graphql_styleguide.md#graphiql). -This section describes the steps required to add your GraphQL examples to GitLab documentation. +This section describes the steps required to add your GraphQL examples to +GitLab documentation. ### Add a dedicated GraphQL page -To create a dedicated GraphQL page, create a new `.md` file in the `doc/api/graphql/` directory. -Give that file a functional name, such as `import_from_specific_location.md`. +To create a dedicated GraphQL page, create a new `.md` file in the +`doc/api/graphql/` directory. Give that file a functional name, such as +`import_from_specific_location.md`. ### Start the page with an explanation -Include a page title that describes the GraphQL functionality in a few words, such as: +Include a page title that describes the GraphQL functionality in a few words, +such as: ```markdown # Search for [substitute kind of data] ``` -Describe the search. One sentence may be all you need. More information may help -readers learn how to use the example for their GitLab deployments. +Describe the search. One sentence may be all you need. More information may +help readers learn how to use the example for their GitLab deployments. ### Include a procedure using the GraphiQL explorer -The GraphiQL explorer can help readers test queries with working deployments. Set up the section with the following: +The GraphiQL explorer can help readers test queries with working deployments. +Set up the section with the following: - Use the following title: @@ -1958,8 +2142,8 @@ The GraphiQL explorer can help readers test queries with working deployments. Se ## Set up the GraphiQL explorer ``` -- Include a code block with the query that anyone can include in their instance of - the GraphiQL explorer: +- Include a code block with the query that anyone can include in their + instance of the GraphiQL explorer: ````markdown ```graphql @@ -1979,22 +2163,23 @@ The GraphiQL explorer can help readers test queries with working deployments. Se - Include a screenshot of the result in the GraphiQL explorer. Follow the naming convention described in the [Save the image](#save-the-image) section. -- Follow up with an example of what you can do with the output. - Make sure the example is something that readers can do on their own deployments. +- Follow up with an example of what you can do with the output. Make sure the + example is something that readers can do on their own deployments. - Include a link to the [GraphQL API resources](../../api/graphql/reference/index.md). ### Add the GraphQL example to the Table of Contents -You'll need to open a second MR, against the [GitLab Docs repository](https://gitlab.com/gitlab-org/gitlab-docs/). +You'll need to open a second MR, against the [GitLab documentation repository](https://gitlab.com/gitlab-org/gitlab-docs/). -We store our Table of Contents in the `default-nav.yaml` file, in the `content/_data` -subdirectory. You can find the GraphQL section under the following line: +We store our Table of Contents in the `default-nav.yaml` file, in the +`content/_data` subdirectory. You can find the GraphQL section under the +following line: ```yaml - - category_title: GraphQL +- category_title: GraphQL ``` -Be aware that CI tests for that second MR will fail with a bad link until the main MR -that adds the new GraphQL page is merged. +Be aware that CI tests for that second MR will fail with a bad link until the +main MR that adds the new GraphQL page is merged. And that's all you need! diff --git a/doc/development/documentation/workflow.md b/doc/development/documentation/workflow.md index c3e15cb1b2b..488c71a6328 100644 --- a/doc/development/documentation/workflow.md +++ b/doc/development/documentation/workflow.md @@ -29,7 +29,7 @@ is added or updated. The following are added by the issue or merge request autho The following are also added by members of the Technical Writing team: -- A documentation [scoped label](../../user/project/labels.md#scoped-labels-premium) with the +- A documentation [scoped label](../../user/project/labels.md#scoped-labels) with the `docs::` prefix. For example, `~docs::improvement`. - The `~Technical Writing` [team label](../contributing/issue_workflow.md#team-labels). |