Your PR may take time to be reviewed by a committer, in special specially during release phases, so be patient.
Bootstrapping (needs to be done only once)
You will not Since you don't have write permission permissions to the github apache mirror, you need to fork https://github.com/apache/incubator-netbeans to your own repositories locally.
You need to clone the forked repository and setup your name and mailemail in github. This will also may help git to rebase in order to fulfill its task.
git config --global user.name "John Doe"
git config --global user.email "firstname.lastname@example.org"
Also add the Apache NetBeans incubator project as your upstream in order to submit PRs:
git remote add upstream https://github.com/apache/incubator-netbeans.git
You now want need to create a Pull Request for a fix or a new feature. Pull Request Requests are not fixed in time. I If you change your history the PR will be impacted.
A PR will be reviewed by committers and they may ask you additional work.To easy ease your work it's better to create a branches branch per feature that you want to submit as Pull Request.
Creating and pointing at at a new branch from master requires 3 steps:
git checkout master
git branch mywork
git checkout mywork
You can may then codeimplement your changes, commit and push to your forked repository. You can then use the github UI to create a Pull request from your branch.
You will need an ICLA (Individual Contributor License Agreement) for important modifications.
Commit The commit message related to JIRA issue must start with [NETBEANS-<issue number>]
If the PR is merged into master as-is then all these commits will be in the master too, forever. Therefore, in this example, all three commits should be squashed into one so that only X is left.
<How to squash guide here>https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History
After submission (and certainly after someone starts reviewing the PR) you shouldn't touch the PR's history.
Over time your Pull Request is likely to go stale. A "stale" pull request is one that is no longer up to date with the main line of development, and it needs to be updated before it can be merged into the project. This typically happens because there 's ve meanwhile been changes in the main branch on the same files that are included in the PR, thus resulting in a merge conflict.
- Before starting to code, you may want it is a good practice to open an issue (PTR) first and discuss it in the developer mailing list (Mailing lists), by doing so giving the reason for submitting your pull request so that it is clear and more experienced members can suggest appropriate solutions/ideas.
- All commits must include the authors author's full name and email address.
- All new files must include the Apache Software Foundation license header. See any NetBeans source code in case of doubt.
- All commits must contain a meaningful commit message.
- A meaningful commit message holds in the first line a summary of the commit and in the body (beginning on the third-line) an explanation of what was changed and why it was done.
- Remember that in the future this commit message is most probably the only source of information why a change was committed to the code base.
- If the commit fixes a reported issue, the summary line should hold the issue number and title
"[NETBEANS-XXX] Maven pom.xml file corrupted after inserting dependecies"for example.
- A Pull Request can consist of multiple commits. These commits should group the changes into meaningful entities. Fixup commits should be squashed into the base commit they fix.
- For contributors: Be prepared to be asked questions about your PR.
- A reviewer might have questions and you should be able to answer why you did a fix in a certain way and why it is safe and appropriate.
- Remember that the review sometimes takes as long, as creating a patch in the first place.
- Good commit messages help as they anticipate questions.
- For reviewers: Keep in mind that the contributor wants to fix a problem and has put effort into it. So be polite and focused.
- Don't change code that is correct and works.
- Consider a simple loop. In many cases you can switch between for-loop, for-each-loop and stream construct. All are valid solutionsolutions, don't change the code if it is not broken.
- An improvement is a different case. For example a try-with-resource construct is in general more correct , than the try-finally construct which many developers fail to implement correctly.
- Constructs leading to warnings from the
javacare also good candidates for simple fixes.
- Run unit tests and, if you introduce new feature/fixes, add unit tests. So before you start your work, check that unit tests for the module you are working on run correctly and after you are done still dokeep doing.
- If unit tests fail, fixing these would be a good addition to the code base (it would be good to use a separate commit for this)
- Keep your pull requests up-to-date. When the PR can't be merged directly /(it can happen that changes are introduced into the code base, that conflict with your PR,) you should then update it accordingly.
- Follow the coding conventions of the file. Your code should match that style and not stand out. For new files, please follow the code conventions for the NetBeans code base: https://netbeans.org/community/guidelines/code-conventions.html
- Try to keep the code readable, maintainable, easy to debug and performant.
If the source code is not to be translated then avoid adding `// NOI18N` comments to the string literals, ; this just adds clutter and makes the code less readable.