However, if you know how to use git and would rather have a local copy (because, why wouldn't you?!), then you can clone it:
git clone firstname.lastname@example.org:moose/Moose.git
If, at some point, you think you'd like to contribute a patch, please see ``Getting Started''.
Cabal members are listed in Moose and can often be found on irc in the <irc://irc.perl.org/#moose-dev> channel.
At this stage, no new features will even be considered for addition into the core without first being vetted as a MooseX module, unless it is absolutely 100% impossible to implement the feature outside the core.
If you think it is 100% impossible, please come discuss it with us on IRC or via e-mail. Your feature may need a small hook in the core, or a refactoring of some core modules, and we are definitely open to that.
Moose was built from the ground up with the idea of being highly extensible, and quite often the feature requests we see can be implemented through small extensions. Try it, it's much easier than you might think.
For minor releases, patches will be committed to "master", and backported (cherry-picked) to the appropriate stable branch as needed. A stable branch is only updated by someone from the Cabal during a release.
Larger, longer term branches can also be created in the root namespace (i.e. at the same level as master and stable). This may be appropriate if multiple people are intending to work on the branch. These branches should not be rebased without checking with other developers first.
Of course, to ensure that your first experience is as productive and satisfying as possible, you should probably take some time to read over this entire POD document. Doing so will give you a full understanding of how Moose developers and maintainers work together and what they expect from one another. Done? Great!
Next, assuming you have a GitHub account, go to <http://github.com/moose/Moose> and fork the repository (see <https://help.github.com/articles/fork-a-repo>). This will put an exact replica of the Moose repository into your GitHub account, which will serve as a place to publish your patches for the Moose maintainers to review and incorporate.
Once your fork has been created, switch to your local working repository directory and update your "origin" remote's push URL. This allows you to use a single remote ("origin") to both pull in the latest code from GitHub and also push your work to your own fork:
# Replace YOUR_USERNAME below with your GitHub username git remote set-url --push origin email@example.com:YOUR_USERNAME/moose.git
You can verify your work:
$ git remote -v origin firstname.lastname@example.org:moose/Moose.git (fetch) origin email@example.com:YOUR_USERNAME/moose.git (push)
What follows is a more detailed rundown of that workflow. Please make sure to review and follow the steps in the previous section, ``Getting Started'', if you have not done so already.
Update Your Repository
Update your local copy of the master branch from the remote:
git checkout master git pull --rebase
Create Your Topic Branch
Now, create a new topic branch based on your master branch. It's useful to use concise, descriptive branch names such as: pod-syntax-contrib, feat-autodelegation, patch-23-role-comp, etc. However, we'll just call ours "my-feature" for demonstration purposes:
git checkout -b topic/my-feature
Hack. Commit. Repeat.
While you're hacking, the most important thing to remember is that your topic branch is yours to do with as you like. Nothing you do there will affect anyone else at this point. Commit as often as little or as often as you need to and don't let perfection get in the way of progress. However, don't try to do too much as the easiest changes to integrate are small and focused.
If it's been a while since you created your topic branch, it's often a good idea to periodically rebase your branch off of the upstream master to reduce your work later on:
git fetch # or, git remote update git rebase origin/master # or, git pull --rebase origin master
You should also feel free to publish (using "push --force" if necessary) your branch to your GitHub fork if you simply need feedback from others. (Note: actual collaboration takes a bit more finesse and a lot less "--force" however).
Clean Up Your Branch
Finally, when your development is done, it's time to prepare your branch for review. Even the smallest branches can often use a little bit of tidying up before they are unleashed on a reviewer. Clarifying/cleaning up commit messages, reordering commits, splitting large commits or those which contain different types of changes, squashing related or straggler commits are all highly worthwhile activities to undertake on your topic branch.
Remember: Your topic branch is yours. Don't worry about rewriting its history or breaking fast-forward. Some useful commands are listed below but please make sure that you understand what they do as they can rewrite history:
- git commit --amend - git rebase --interactive - git cherry-pick
Ultimately, your goal in cleaning up your branch is to craft a set of commits whose content and messages are as focused and understandable as possible. Doing so will greatly increase the chances of a speedy review and acceptance into the mainline development.
Rebase on the Latest
Before your final push and issuing a pull request, you need to ensure that your changes can be easily merged into the master branch of the upstream repository. This is done by once again rebasing your branch on the latest "origin/master".
git fetch # or, git remote update git rebase origin/master # or, git pull --rebase origin master
Publish and Pull Request
Now it's time to make your final push of the branch to your fork. The "--force" flag is only necessary if you've pushed before and subsequently rewriting your history:
git push --force
After your branch is published, you can issue a pull request to the Moose Cabal. See <https://help.github.com/articles/using-pull-requests> for details.
It should be noted that if you want your specific branch to be approved, it is your responsibility to follow this process and advocate for your branch.
New documentation is always welcome, but should also be reviewed by a cabal member for accuracy.
TODO tests are basically feature requests, see our ``New Features'' section for more information on that. If your feature needs core support, create a "topic/" branch using the ``Development Workflow'' and start hacking away.
Failing tests are basically bug reports. You should find a core contributor and/or cabal member to see if it is a real bug, then submit the bug and your test to the RT queue. Source control is not a bug reporting tool.
Make sure you have reviewed ``New Features'' to be sure that you are following the guidelines. Do not be surprised if a new feature is rejected for the core.
Ideally you will have run the xt/author/test-my-dependents.t script to be sure you are not breaking any MooseX module or causing any other unforeseen havoc. If you do this (rather than make us do it), it will only help to hasten your branch's approval.
We have a policy for what we see as sane ``BACKWARDS COMPATIBILITY'' for Moose. If your changes break back-compat, you must be ready to discuss and defend your change.
# major releases (including trial releases) git checkout master # minor releases git checkout stable/X.YY # do final changelogging, etc vim dist.ini # increment version number git commit dzil release # or dzil release --trial for trial releases git commit # to add the actual release date git branch stable/X.YY # only for non-trial major releases
Moose uses Dist::Zilla to manage releases. Although the git repository comes with a "Makefile.PL", it is a very basic one just to allow the basic "perl Makefile.PL && make && make test" cycle to work. In particular, it doesn't include any release metadata, such as dependencies. In order to get started with Dist::Zilla, first install it: "cpanm Dist::Zilla", and then install the plugins necessary for reading the "dist.ini": "dzil authordeps | cpanm".
Moose releases fall into two categories, each with their own level of release preparation. A minor release is one which does not include any API changes, deprecations, and so on. In that case, it is sufficient to simply test the release candidate against a few different Perls. Testing should be done against at least two recent major versions of Perl (5.8.8 and 5.10.1, for example). If you have more versions available, you are encouraged to test them all. However, we do not put a lot of effort into supporting older 5.8.x releases.
For major releases which include an API change or deprecation, you should run the xt/author/test-my-dependents.t test. This tests a long list of MooseX and other Moose-using modules from CPAN. In order to run this script, you must arrange to have the new version of Moose in Perl's include path. You can use "prove -b" and "prove -I", install the module, or fiddle with the "PERL5LIB" environment variable, whatever makes you happy.
This test downloads each module from CPAN, runs its tests, and logs failures and warnings to a set of files named test-mydeps-$$-*.log. If there are failures or warnings, please work with the authors of the modules in question to fix them. If the module author simply isn't available or does not want to fix the bug, it is okay to make a release.
git remote update git checkout -b topic/my-emergency-fix origin/master # hack git commit
Then a cabal member merges into "master", and backports the change into "stable/X.YY":
git checkout master git merge topic/my-emergency-fix git push git checkout stable/X.YY git cherry-pick -x master git push # release
"commit --amend", "rebase --interactive", etc. are not allowed, and should only be done in topic branches. Committing to master is still done with the same review process as a topic branch, and the branch must merge as a fast forward.
This is pretty much the way we're doing branches for large-ish things right now.
Obviously there is no technical limitation on the number of branches. You can freely create topic branches off of project branches, or sub projects inside larger projects freely. Such branches should incorporate the name of the branch they were made off so that people don't accidentally assume they should be merged into master:
git checkout -b my-project--topic/foo my-project
Failed branches may be kept, but should be moved to "attic/" to differentiate them from in-progress topic branches.
If your code change/addition is deep within the bowels of Moose and your test exercises this feature in a non-obvious way, please add some comments either near the code in question or in the test so that others know.
We also greatly appreciate documentation to go with your changes, and an entry in the Changes file. Make sure to give yourself credit! Major changes or new user-facing features should also be documented in Moose::Manual::Delta.
Our policy for handling backwards compatibility is documented in more detail in Moose::Manual::Support.
This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.