RFCs for Bundler 🎉

0000-template.md

@@ -0,0 +1,50 @@
+- Start Date: (fill me in with today's date, YYYY-MM-DD)
+- RFC PR: (leave this empty)
+- Ember Issue: (leave this empty)
+
+# Summary
+
+One paragraph explanation of the feature.
+
+# Motivation
+
+Why are we doing this? What use cases does it support? What is the expected
+outcome?
+
+# Detailed design
+
+This is the bulk of the RFC. Explain the design in enough detail for somebody
+familiar with the framework to understand, and for somebody familiar with the
+implementation to implement. This should get into specifics and corner-cases,
+and include examples of how the feature is used. Any new terminology should be
+defined here.
+
+# How We Teach This
+
+What names and terminology work best for these concepts and why? How is this
+idea best presented? As a continuation of existing Ember patterns, or as a
+wholly new one?
+
+Would the acceptance of this proposal mean the Ember guides must be
+re-organized or altered? Does it change how Ember is taught to new users
+at any level?
+
+How should this feature be introduced and taught to existing Ember
+users?
+
+# Drawbacks
+
+Why should we *not* do this? Please consider the impact on teaching Ember,
+on the integration of this feature with other existing and planned features,
+on the impact of the API churn on existing apps, etc.
+
+There are tradeoffs to choosing any path, please attempt to identify them here.
+
+# Alternatives
+
+What other designs have been considered? What is the impact of not doing this?
+
+# Unresolved questions
+
+Optional, but suggested for first drafts. What parts of the design are still
+TBD?

CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [email protected]. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

README.md

@@ -0,0 +1,129 @@
+# RubyGems + Bundler RFCs
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+However, some changes are more substantial, and we ask that these be put
+through a bit of a design process and produce a consensus in the community and
+among the [maintainers].
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and predictable path for new features and projects.
+
+[Active RFC List](https://github.com/rubygems/rfcs/pulls)
+
+## When you need to follow this process
+
+You need to follow this process if you intend to make "substantial" changes to
+RubyGems, Bundler, or their documentation. What constitutes a "substantial"
+change is evolving based on community norms, but may include the following.
+
+   - A new feature that creates new API, command, or option surface area.
+   - The removal of features that have already shipped in a minor release.
+   - The introduction of new idiomatic usage or conventions, even if they
+     do not include code changes.
+
+Some changes do not require an RFC:
+
+  - Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+    not change meaning".
+  - Additions that strictly improve objective, numerical quality criteria
+    (warning removal, speedup, better platform coverage, more parallelism, trap
+    more errors, etc.)
+  - Addition or removal of warnings.
+  - Additions only likely to be noticed by other implementors, invisible to end
+    users.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+It's often helpful to get feedback on your concept before diving into the level
+of API design detail required for an RFC. **You may open an issue on this repo
+to start a high-level discussion**, with the goal of eventually formulating an
+RFC pull request with the specific implementation design.
+
+## What the process is
+
+In short, any major feature nedes an RFC that has been merged into this RFC
+repo as a markdown file. At that point the RFC is 'active' and may be
+implemented with the goal of eventual inclusion into Bundler and/or RubyGems.
+
+* Fork [the RFC repo](http://github.com/bundler/rfcs) (that's this one!)
+* Copy `0000-template.md` to `text/0000-my-feature.md` (Where 'my-feature' is
+  descriptive—don't assign an RFC number yet.)
+* Fill in the RFC. Put care into the details: RFCs should include convincing
+  motivation, demonstrate understanding of the impact of the design, and be
+  clear about drawbacks or alternatives.
+* Submit a pull request. As a pull request the RFC will receive design feedback
+  from the larger community, and the author should be prepared to revise it in
+  response.
+* Build consensus and integrate feedback. RFCs that have broad support are much
+  more likely to make progress than those that don't receive any comments.
+* RFCs rarely go through this process unchanged, especially as alternatives and drawbacks are shown. You can make edits, big and small, to the RFC to clarify or change the design, but make changes as new commits to the PR, and leave a comment on the PR explaining your changes. Specifically, do not squash or rebase commits after they are visible on the PR.
+* RFCs that are candidates for inclusion will enter a "final comment period"
+  lasting 7 days. The beginning of this period will be signaled with a comment
+  and tag on the RFC's pull request. At that point, the [Bundler Twitter
+  account](https://twitter.com/bundlerio) will post a tweet about the RFC to
+  attract the community's attention.
+* An RFC can be modified based upon feedback from the [maintainers] and
+  community. Significant modifications may trigger a new final comment period.
+* An RFC may be rejected by the [maintainers] after public discussion has
+  settled and comments have been made summarizing the rationale for rejection.
+  A [maintainer] should then close the RFC's associated pull request.
+* An RFC may be accepted at the close of its final comment period. A
+  [maintainer] will merge the RFC's associated pull request, at which point the
+  RFC will become 'active'.
+
+## The RFC life-cycle
+
+Once an RFC becomes active then authors may implement it and submit the feature
+as a pull request to the Rust repo. Being 'active' is not a rubber stamp, and
+in particular still does not mean the feature will ultimately be merged; it
+does mean that in principle all the major stakeholders have agreed to the
+feature and are amenable to merging it.
+
+Furthermore, the fact that a given RFC has been accepted and is 'active'
+implies nothing about what priority is assigned to its implementation, nor does
+it imply anything about whether a Rust developer has been assigned the task of
+implementing the feature. While it is not necessary that the author of the RFC
+also write the implementation, it is by far the most effective way to see an
+RFC through to completion: authors should not expect that other project
+developers will take on responsibility for implementing their accepted feature.
+
+Modifications to active RFC's can be done in follow-up PR's. We strive to write
+each RFC in a manner that it will reflect the final design of the feature; but
+the nature of the process means that we cannot expect every merged RFC to
+actually reflect what the end result will be at the time of the next major
+release.
+
+In general, once accepted, RFCs should not be substantially changed. Only very
+minor changes should be submitted as amendments. More substantial changes
+should be new RFCs, with a note added to the original RFC.
+
+## Implementing an RFC
+
+The author of an RFC is not obligated to implement it. Of course, the RFC
+author (like any other developer) is welcome to post an implementation for
+review after the RFC has been accepted.
+
+If you are interested in working on the implementation for an 'active' RFC, but
+cannot determine if someone else is already working on it, feel free to ask
+(e.g. by leaving a comment on the associated issue).
+
+## Reviewing RFC's
+
+The [maintainers] will review open RFC pull requests, giving feedback and
+eventually accepting or rejecting each one. Every accepted feature should have
+a maintainer champion, who will represent the feature and its progress.
+
+#### Inspiration
+
+The RubyGems + Bundler RFC process is inspired by the [Rust], [Ember.js], and [Swift] RFC processes.
+
+[Rust]: https://github.com/rust-lang/rfcs
+[Swift]: https://github.com/apple/swift-evolution
+[Ember.js]: https://github.com/emberjs/rfcs
+[maintainer]: http://bundler.io/contributors.html
+[maintainers]: http://bundler.io/contributors.html