# Infrastructure/Phabricator

Phabricator is KDE's task management and patch review system. This page is intended to serve as a general-purpose introduction to the most important aspects: submitting and reviewing patches. It should not take long before you are happily using Phabricator.

Information
The KDE community does not use the Phabricator bug reporting function. We continue to use bugzilla at https://bugs.kde.org

## Getting help

The official documentation is in the Phabricator book and on their website -- note that since everything is under rapid development, most of the documentation is incomplete. A good way to find the information you're looking for is to search Phabricator upstream.

## Posting a Patch using the website

Once you have set up your development environment and created a patch, you can submit it using Phabricator!

First, create a diff file using git diff (or git format-patch). Log in to Phabricator and enter Code Review. Click the +Create Diff button in the upper-right corner of the screen. Paste the text of the diff or upload the file using the file dialog. Select the project at the bottom; if you start typing it will perform a search among active projects. For a reviewer, use the name of the project itself (the text-field will auto-complete valid projects to help you out). In some cases, you will want to request a review from particular people instead of or in addition to the group.

Note
You must make sure that there is at least one subscriber or reviewer for the diff. Phabricator automatically adds the correct subscriber(s) for many projects when the diff is submitted, but not all of them. If there are no subscribers or reviewers, nobody will get notified.

Once the patch lands, the Title will become the git commit message, so please follow commit message best practices.

In the Summary section, write at least one sentence describing your change and why it is necessary, adding more detail if necessary.

If your patch is intended to fix a Bugzilla ticket, include one of the following on its own line, at the end of the Summary section, below all other text:

BUG: 385942


or

FEATURE: 384936


(Just the Bugzilla ticket number, not the full URL)

Use BUG: If the Bugzilla describes a bug, and FEATURE if the Bugzilla ticket describes a feature request. Either of these tags will cause that Bugzilla ticket to be automatically closed when the patch is committed. Note that these tags cannot appear on the first line of the Summary section; there must be some text before them.

If you added the BUG: or FEATURE: tag, also add another tag indicating what version receives the fix or new feature:

FIXED-IN: [version]


Replace [version] with an appropriate version string; see Guidelines and HOWTOs/Write a version string to find out how to write one. If you can't figure it out, don't worry about it and just omit the tag; a KDE developer will help you add it during code review.

Here is more information about other special messages that interact with Bugzilla tickets. You can also add special messages that interact with other Phabricator tools (e.g. Maniphest tasks).

### Include some screenshots

For patches that change something about the user interface, it's customary to include a screenshot of how the interface looks with your patch. Bonus points for including a "Before" image too, so reviewers can easily compare them.

# Using Arcanist to post patches

## What is Arc?

Using the web UI to post patches gets tiresome after a while. Arcanist is a tool to simplify and speed up the process of posting, updating, and merging Phabricator patches.

## Installing Arcanist

$sudo dnf install arcanist  ### openSUSE Tumbleweed: $ sudo zypper ar -f https://download.opensuse.org/repositories/devel:tools:scm/openSUSE_Tumbleweed/devel:tools:scm.repo
$sudo zypper install arcanist  Leap 15: $ sudo zypper ar -f https://download.opensuse.org/repositories/devel:tools:scm/openSUSE_Leap_15.0/devel:tools:scm.repo


### Windows

The most non-obvious step is that you will need to configure your PHP installation to use Curl. This requires editing the php.ini configuration file to add the line extension_dir = "ext" and add php_curl to the list of extensions. After adding php.exe to your PATH and installing arcanist/libphutil, you can run arc by defining a function in your Powershell profile:

 function arc { php -f "C:\path\to\arcanist.php" -- $args } After you have installed Arc, you can learn more using man arc or arc --help. Another command useful for getting a feel for Phabricator's style is arc anoid. ## Set your git identity You will need to tell git who you really are, so your patches will include correct authorship information and can be correctly attributed to yourself. This only needs to be done once: $ git config --global user.name <Your real name>
$git config --global user.email <Your identity.kde.org email address>  ## Workflow The sanest and easiest way to use arc is to follow a typical feature branch workflow: keep your master branch synchronized with the upstream repository, and make all changes on separate branches. Each patch needs its own private, temporary branch. Once your patch has been merged, delete the feature branch, and make another new branch for the next patch. ### Step 1: Create a new diff Before editing anything, create a new branch for your patch: $ git checkout -t -b <branchname>  # the -t flag makes git "track" the current branch


Now make changes on the feature branch. When you're ready to have your changes reviewed, enter the following command:



### Step 3: Land your diff

If you do not have a KDE Developer Account, then someone who does will have to land your patch for you. Otherwise, you can do it yourself once the patch has been accepted and reviewers have given you permission to "ship it!"

First make sure that the world is sane, and that only your patch will be landed:

$[make sure you are on your feature branch]$ arc land --preview


The output of that command should show only the commit message for your patch. If you see more than that, stop and ask your reviewers for help.

This is simple:

$arc land  #### Landing on the "Stable branch" By default, arc will land the patch onto whatever branch was the parent . For example, if you branched from master; arc will land on master; if you branched from Applications/18.04, arc will land on that branch instead. Often you will find yourself being asked to land your diff on the "stable branch", even though you originally branched from master. To make this work, rebase your patch on the stable branch: $ [make sure you are on your feature branch]
$git fetch$ git rebase --onto origin/Applications/18.04 master
$arc land --onto Applications/18.04  Note that in most repositories, after committing to the "stable" branch you are expected to merge the "stable" branch to "master" afterwards (check the Git history to be sure): $ git checkout master
$git merge -Xours origin/Applications/18.04$ git push


## Arcanist Tips & Tricks

### Look before you diff

You can check with arc which what Arcanist will do before performing the actual upload with arc diff if you are unsure what will happen. In particular, look for which commits will be included in your Diff.

### arc diff: specify a revision manually

Sometimes - if you messed up with your git branches - arc cannot properly determine which revision (D12345) should be updated. In this case you can use arc diff --update D12345. See arc help diff.

### Updating the summary of the Differential from the local Git commit message

If you changed the commit message locally and want to update the text in the summary in Differential, call Arc like this:

$arc diff --edit --verbatim  ### Updating the local Git commit message from changes done on Phabricator If you or someone else updated the title, summary, test plan, reviewers or subscribers of a Diff using the web editor in Phabricator, Arcanist allows to sync those changes back to your local Git commit message: $ arc amend


Note that in general Arcanist will do this automatically for you once you arc land.

Once in a while a reviewer will tell you to do specific things. This section will help you to figure out what is meant to be done.

### "Please do that in a separate commit"

Should your patch contain an unrelated change, your reviewer will ask you to undo that part and possibly open a new Diff for that. Here is what you can do:

If the change in question is in a separate commit on your local branch:

$git revert <unrelated change>$ arc diff # this updates the first Diff
$git checkout -b <new branch name> master$ git cherry-pick <unrelated change>
$arc diff # this creates a new Diff for the unrelated change  If you mixed different changes in a single commit on your local branch: $ git reset HEAD^
$git add -p # type "?" for help, then pick all hunks you want to keep$ git stash # the stash now contains the hunks for the second patch
$git commit$ arc diff # this updates the first Diff
$git checkout -b <new branch name> master$ git stash pop
$git commit$ arc diff # this creates a new Diff for the unrelated change


In case this does not work for you, there's always the plain old copy-and-paste. In general, it is best to avoid adding unrelated changes from the beginning. :-)

### Marking patches as dependent on other patches

Sometimes you will want to submit a patch that depends on another patch, creating a dependency chain.

#### If each patch is intended for a different project

Example: you submit a patch to add new feature in KIO, and then submit another patch for Dolphin that uses that feature. Here's what you do:

1. Create your first patch as above
2. When creating the second patch, add the following to its own line in the "Summary" section:
Depends on DXXXX
(Replace "DXXXX" with the ID of the dependent patch, not the full URL)

#### If the patches are all for the same project

Example: you are implementing multiple new features for a single project that each depend on the patch for the prior feature. Here's what you do:

1. Create a branch to track the first feature:
$git checkout -b <branch name for feature 1> --track origin/master  Then implement the feature and make a commit. 2. Then create a branch for your second feature, tracking the first branch: git checkout -b <branch name for feature 2> --track <branch name for feature 1>  As above, implement the feature and make a commit. Continue this pattern for any other required dependent features. 3. When you're ready to turn your dependency chain feature branches into patches, do the following: $ git checkout <branch name for feature 1>
$arc diff [then go through the process of creating the patch normally]$ git checkout <branch name for feature 2>
git commit --amend  [then add the special text "Depends on DXXXX", replacing DXXXX with the ID of the first patch
$arc diff [then go through the process of creating the patch normally]  ...And so on. 4. After you get comments, you will have to make changes to your patches and re-base dependent patches: $ git checkout <branch name for feature 1>
[Make changes]
$git add -u$ git commit
$arc diff$ git checkout <branch name for feature 2>
$git rebase <branch name for feature 1>$ git add -u
$git commit$ arc diff


...And so on.

5. When you're ready to land any or all of your patches, do it in sequence, starting from the patch with no unmet dependencies:
$git checkout <branch name for feature 1>$ arc land
$git checkout <branch name for feature 2>$ git rebase origin/<target branch>
$arc land  # How to review someone else's patch Arcanist (arc) makes it easy to review someone's patch (if you haven't already, see 2.2 Installing Arcanist). First, find the patch's revision ID. For example, for https://phabricator.kde.org/D11184, the ID is D11184. Next, check out or enter the source repository for the patch. The repository is listed on the web UI: $ git clone git://anongit.kde.org/konsole.git
# If you've already checked out the repository, you don't need to clone it again, just cd do it


Now, apply the patch:

\$ arc patch <revision ID>


Answer y to any questions that are posed. Arc will automatically create a branch named arcpatch-<revision ID> for the patch, so it won't damage your checkout at all.

Now it's time to compile and run the software to make sure that the patch does what it says it does and doesn't cause any regressions! If you haven't already set up a development environment, it's time to do so. See Get_Involved/development#Set_up_your_development_environment. Follow the instructions to compile and run the program.

## Perform QA

It's important to thoroughly test patches to ensure that bad code and regressions don't slip in. This is the entire purpose of having a review infrastructure; it is very important.

First execute the Test Plan that the submitter wrote. Does it all still work for you? If not, return to the web UI and Request Changes, writing a detailed comment explaining what didn't work. It is permissible to do this even if you have not been specified as a reviewer!

If the original Test Plan succeeds, try to break the patch. Here are some ideas:

1. Remove the program's configuration file (~/.config/<program name>rc ) and re-open it
2. Try the program with a HiDPI scale factor (or without one) or with a different default font size
3. If it's a new feature, feed it unexpected input
4. Test related functionality

Try to break it! An acceptable patch will handle corner cases and variations in configuration. The price of configurability is vigilant testing! We owe it to our users to test using many configurations, not just the defaults or our personal settings.

## Perform code review

Note
Need a section on code review here, preferably written by a core KDE developer or another very experienced developer

## Engage with the author and other reviewers

After you have run the program and evaluated the patch, it's time to leave some review comments on the webpage (https://phabricator.kde.org/<revision ID>). If you have been specified as a reviewer, or are a member of a group that has been specified as a reviewer, it is permissible to Accept the patch. But keep in mind that reviewing involves responsibility: you are giving a thumbs-up to code that will be run potentially by millions of people.

# Customization

## Creating custom dashboard feeds

You can customize your Phabricator homepage by creating a new dashboard. However, the selection of what you can post on your dashboard is limited. The defaults will show all tasks from all projects.

To narrow this down, you need to define a custom query to serve as a filter. For example, if you work on Plasma Mobile and want to monitor the to-do list, perhaps you want to show only tasks which are in the Plasma Mobile and are tagged as open. To do that, enter Maniphest, select "advanced search," select the appropriate terms, then click "save custom query." You can give your query a name. Once it is saved, the query will become available as a new filter for creating feeds on your dashboard. (In Differential you seem to need to perform the test search before the "save query" button becomes visible.)