Spring Integration Contributor Guidelines
Have something you’d like to contribute to Spring Integration? We welcome pull requests, but ask that you carefully read this document first to understand how best to submit them; what kind of changes are likely to be accepted; and what to expect from the Spring team when evaluating your submission.
Please refer back to this document as a checklist before issuing any pull request; this will save time for everyone!
Code of Conduct
Understand the basics
Not sure what a pull request is, or how to submit one? Take a look at GitHub’s excellent documentation: Using Pull Requests first.
Search GitHub (or JIRA) issues first; create one if necessary
Is there already an issue that addresses your concern? Search the GitHub issue tracker (or JIRA issue tracker) to see if you can find something similar. If not, please create a new issue in GitHub before submitting a pull request unless the change is truly trivial, e.g. typo fixes, removing compiler warnings, etc.
Sign the contributor license agreement
If you have not previously done so, please fill out and submit the Contributor License Agreement (CLA).
Very important, before we can accept any Spring Integration contributions, we will need you to sign the CLA. Signing the CLA does not grant anyone commit rights to the main repository, but it does mean that we can accept your contributions, and you will get an author credit if we do.
Fork the Repository
Hit the "fork" button and choose your own github account as the target
For more detail see Fork A Repo.
Setup your Local Development Environment
git clone --recursive email@example.com:<your-github-username>/spring-integration.git
git remote showyou should see only 'origin' - which is the fork you created for your own github account
git remote add upstream firstname.lastname@example.org:spring-projects/spring-integration.git
git remote showyou should now see 'upstream' in addition to 'origin' where 'upstream' is the Spring repository from which releases are built
git fetch --all
git branch -ayou should see branches on origin as well as upstream, including 'master'
A Day in the Life of a Contributor
Always work on topic branches (Typically use the GitHub issue ID as the branch name).
For example, to create and switch to a new branch for issue 123:
git checkout -b GH-123
You might be working on several different topic branches at any given time, but when at a stopping point for one of those branches, commit (a local operation).
Please follow the "Commit Guidelines" described in this chapter of Pro Git.
Then to begin working on another issue (say 101):
git checkout GH-101. The -b flag is not needed if that branch already exists in your local repository.
When ready to resolve an issue or to collaborate with others, you can push your branch to origin (your fork), e.g.:
git push origin GH-123
If you want to collaborate with another contributor, have them fork your repository (add it as a remote) and
git fetch <your-username>to grab your branch. Alternatively, they can use
git fetch --allto sync their local state with all of their remotes.
If you grant that collaborator push access to your repository, they can even apply their changes to your branch.
When ready for your contribution to be reviewed for potential inclusion in the master branch of the canonical
spring-integrationrepository (what you know as 'upstream'), issue a pull request to the SpringSource repository (for more detail, see Using pull requests).
The project lead may merge your changes into the upstream master branch as-is, he may keep the pull request open yet add a comment about something that should be modified, or he might reject the pull request by closing it.
A prerequisite for any pull request is that it will be cleanly merge-able with the upstream master’s current state. This is the responsibility of any contributor. If your pull request cannot be applied cleanly, the project lead will most likely add a comment requesting that you make it merge-able. For a full explanation, see the Pro Git section on rebasing. As stated there: "> Often, you’ll do this to make sure your commits apply cleanly on a remote branch — perhaps in a project to which you’re trying to contribute but that you don’t maintain."
Keeping your Local Code in Sync
As mentioned above, you should always work on topic branches (since 'master' is a moving target). However, you do want to always keep your own 'origin' master branch in synch with the 'upstream' master.
Within your local working directory, you can sync up all remotes' branches with:
git fetch --all
While on your own local master branch:
git pull upstream master(which is the equivalent of fetching upstream/master and merging that into the branch you are in currently)
Now that you’re in synch, switch to the topic branch where you plan to work, e.g.:
git checkout -b GH-123
When you get to a stopping point:
If changes have occurred on the upstream/master while you were working you can sync again:
Switch back to master:
git checkout master
git pull upstream master
Switch back to the topic branch:
git checkout GH-123(no -b needed since the branch already exists)
Rebase the topic branch to minimize the distance between it and your recently synced master branch:
git rebase master(Again, for more detail see the Pro Git section on rebasing).
Note While it is generally recommended to not re-write history by using
push --force, and we do not do this on
master(and release) branches in the main repo, we require topic branches for pull requests to be rebased before merging, in order to maintain a clean timeline and avoid "merge" commits.
If, while rebasing for the merge, we find significant conflicts, we may ask you to rebase and
push --forceto your topic branch after resolving the conflicts.
Assuming your pull request is merged into the 'upstream' master, you will end up pulling that change into your own master eventually and, at that time, you may decide to delete the topic branch from your local repository and your fork (origin) if you pushed it there.
to delete the local branch:
git branch -d GH-123
to delete the branch from your origin:
git push origin :GH-123
Maintain a linear commit history
When merging to master, the project always uses fast-forward merges. As discussed above, when issuing pull requests, please ensure that your commit history is linear. From the command line you can check this using:
log --graph --pretty=oneline
As this may cause lots of typing, we recommend creating a global alias, e.g.
git logg for this:
git config --global alias.logg 'log --graph --pretty=oneline'
This command, will provide the following output, which in this case shows a nice linear history:
* c129a02e6c752b49bacd4a445092a44f66c2a1e9 GH-2721 Increase Timers on JDBC Delayer Tests * 14e556ce23d49229c420632cef608630b1d82e7d GH-2620 Fix Debug Log * 6140aa7b2cfb6ae309c55a157e94b44e5d0bea4f GH-3037 Fix JDBC MS Discard After Completion * 077f2b24ea871a3937c513e08241d1c6cb9c9179 Update Spring Social Twitter to 1.0.5 * 6d4f2b46d859c903881a561c35aa28df68f8faf3 GH-3053 Allow task-executor on <reply-listener/> * 56f9581b85a8a40bbcf2461ffc0753212669a68d Update Spring Social Twitter version to 1.0.4
If you see intersecting lines, that usually means that you forgot to rebase you branch. As mentioned earlier, please rebase against master before issuing a pull request.
Follow the Code Style
Please, follow with the Spring Integration Code Style.
@since tags for newly-added public API types and methods e.g.
/** * ... * * @author First Last * @since 3.0 * @see ... */
@author tag with your real name, when you change any class e.g.
/** * ... * * @author First Last */
Submit JUnit test cases for all behavior changes
Search the codebase to find related unit tests and add additional
@Test methods within.
It is also acceptable to submit test cases on a per GH issue basis.
git rebase --interactive,
git add --patch and other tools to "squash" multiple commits into atomic changes.
In addition to the man pages for git, there are many resources online to help you understand how these tools work.
Use your real name in git commits
Please configure git to use your real first and last name for any commits you intend to submit as pull requests. For example, this is not acceptable:
Author: Nickname <email@example.com>
Rather, please include your first and last name, properly capitalized, as submitted against the SpringIO contributor license agreement:
Author: First Last <firstname.lastname@example.org>
This helps ensure traceability against the CLA, and also goes a long way to ensuring useful output from tools like
git shortlog and others.
You can configure this globally via the account admin area GitHub (useful for fork-and-edit cases); globally with
git config --global user.name "First Last" git config --global user.email email@example.com
or locally for the spring-integration repository only by omitting the '--global' flag:
cd spring-integration git config user.name "First Last" git config user.email firstname.lastname@example.org
Run all tests prior to submission
See the checking out and building section of the README for instructions. Make sure that all tests pass prior to submitting your pull request.
Provide a Link to the GitHub issue in the Associated Pull Request
Add a GitHub issue link to your first commit comment of the pull request on the last line, so your commit message may look like this:
GH-1639: Add <spel-function> support Fixes spring-projects/spring-integration#1639 * add `<spel-function>` XSD element * add `SpelFunctionParser` * add `SpelFunctionRegistrar` to avoid introducing some confused 'Method'-bean * add `SpelFunctionRegistrar` collaboration with `IntegrationEvaluationContextFactoryBean` * some refactoring for `IntegrationEvaluationContextFactoryBean` * polishing some failed tests after this change
Please, follow Chris Beams' recommendations in regards to the good commit message: How to Write a Git Commit Message.