Skip to content
This repository has been archived by the owner on Feb 22, 2020. It is now read-only.

Commit

Permalink
Merge branch 'master' into develop
Browse files Browse the repository at this point in the history
  • Loading branch information
@abrokenjester
abrokenjester committed Mar 16, 2019
2 parents 05debf0 + c27425a commit e6c1e56
Show file tree
Hide file tree
Showing 801 changed files with 11,134 additions and 19,257 deletions.
152 changes: 76 additions & 76 deletions .github/CONTRIBUTING.md
View file
Original file line number Diff line number Diff line change
@@ -1,46 +1,47 @@
# How to contribute

So you want to help out making RDF4J better. That's great, we welcome all contributions!
So you want to help out making Eclipse RDF4J better. That's great, we welcome your contributions!
Before you dive in, here are some things you need to know.

**Table of Contents**

- [Legal stuff](#legal-stuff)
- [Creating your contribution](#creating-your-contribution)
- [Workflow](#workflow)
- [Releases](#releases)
- [Release branches](#release-branches)
- [Code formatting](#code-formatting)
- [Workflow](#workflow)

## Legal stuff

RDF4J is a project governed by the [Eclipse Foundation](http://www.eclipse.org/), which has strict [policies and guidelines](https://wiki.eclipse.org/Development_Resources#Policies_and_Guidelines) regarding contributions.
Eclipse RDF4J is a project governed by the [Eclipse Foundation](http://www.eclipse.org/), which has strict [policies and guidelines](https://wiki.eclipse.org/Development_Resources#Policies_and_Guidelines) regarding contributions and intellectual property rights.

In order for any contributions to RDF4J to be accepted, you MUST do the following things:

1. Digitally sign the [Eclipse Contributor Agreement (ECA)](https://www.eclipse.org/legal/ECA.php). You can do this as follows:
### Sign the Eclipse Contributor Agreement
You must digitally sign the [Eclipse Contributor Agreement (ECA)](https://www.eclipse.org/legal/ECA.php). You can do this as follows:

* If you haven't done so already, [register an Eclipse account](https://dev.eclipse.org/site_login/createaccount.php). Use the same email address when you register for the account that you intend to use on Git commit records.
* Log into the [Eclipse projects forge](http://www.eclipse.org/contribute/cla); click on the "Eclipse Contributor Agreement" tab; and complete the form. See the [ECA FAQ](https://www.eclipse.org/legal/ecafaq.php) for more info.

* If you haven't done so already, [register an Eclipse account](https://dev.eclipse.org/site_login/createaccount.php). Use the same email address when you register for the account that you intend to use on Git commit records.
* Log into the [Eclipse projects forge](http://www.eclipse.org/contribute/cla); click on the "Eclipse Contributor Agreement" tab; and complete the form. See the [ECA FAQ](https://www.eclipse.org/legal/ecafaq.php) for more info.
### Link your Github and Eclipse accounts

2. Add your github username in your [Eclipse account settings](https://dev.eclipse.org/site_login/#open_tab_accountsettings).
Add your github username in your [Eclipse account settings](https://dev.eclipse.org/site_login/#open_tab_accountsettings).

3. "Sign-off" your commits
Every commit you make in your patch or pull request MUST be "signed off".
You do this by adding the `-s` flag when you make the commit(s).
### Sign-off every commit

Every commit you make in your patch or pull request MUST be "signed off". You do this by adding the `-s` flag when you make the commit(s).

## Creating your contribution

Once the legalities are out of the way you can dig in. Here's how:

1. Create an issue in the [RDF4J GitHub issue tracker](https://github.com/eclipse/rdf4j/issues) that describes your improvement, new feature, or bug fix. Alternatively, comment on an existing issue to indicate you're keen to help solve it.
1. Create an issue in the [issue tracker](https://github.com/eclipse/rdf4j/issues) that describes your improvement, new feature, or bug fix. Alternatively, comment on an existing issue to indicate you're keen to help solve it.
2. Fork the repository on GitHub.
3. Create a new branch for your changes starting from the `master` branch. See [Workflow](#workflow) for details.
4. Make your changes. Apply [RDF4J code formatting guidelines](#code-formatting)
4. Make your changes. Apply the [RDF4J code formatting guidelines](#code-formatting)
5. Make sure you include tests.
6. Make sure the test suite passes after your changes.
7. Commit your changes into the branch. Use meaningful commit messages. Reference the issue number in the commit message (for example "issue #276: added null check").
8. **Sign off** every commit you do, using the `-s` flag (as explained in the [legal stuff](#legal-stuff).
7. Commit your changes into the branch. Use meaningful commit messages. Reference the issue number in the commit message (for example "eclipse/rdf4j#276: added null check").
8. **Sign off** every commit you do, using the `-s` flag (as explained in the [legal stuff](#legal-stuff)).
9. Optionally squash your commits (not necessary, but if you want to clean your commit history a bit, _this_ is the point to do it).
10. Push your changes to your branch in your forked repository.
11. If your contribution is complete, use GitHub to submit a pull request (PR)
Expand All @@ -50,63 +51,57 @@ Once the legalities are out of the way you can dig in. Here's how:

Once you've put up a PR, we will review your contribution, possibly make some
suggestions for improvements, and once everything is complete it will be merged
into the `master` branch, to be included in the next minor or major release. If
your contribution is a bug fix in an existing release, we will also schedule it
for inclusion in a patch release.

## Workflow
into the `master` branch (if it's a bug fix to be included in the next
maintenance release) or into the `develop` branch (if it's a feature or
improvement to be included in the next minor or major release).

The short-short version for contributors: work from the `master` branch.

The more complete version: RDF4J uses a git branching model where feature
development takes place on branches from the `master` branch. This is where all
development for the next (minor or major) release happens.

Every issue, no matter how small, gets its own branch while under development.
Issue branch names are always prefixed with `issues/`, followed by the issue
number in the [GitHub issue tracker](https://github.com/eclipse/rdf4j/issues),
followed by one or two dash-separated keywords for the issue.
## Code formatting

For example: `issues/#276-rdfxml-sax` is the branch for a fix for
GitHub issue #276, which has to do with RDF/XML and the SAX parser.
Eclipse RDF4J follows the [Eclipse Coding Conventions for Java](https://wiki.eclipse.org/Coding_Conventions), with a couple of minor modifications:

Once a feature/fix is complete, tested, and reviewed (via a Pull Request), it
is merged into master, and the issue branch is closed.
- We use a line width of 120 characters.
- We use Unix line endings (LF).
- We use the following header comment on every Java file:

### Releases
```
/*******************************************************************************
* Copyright (c) ${year} Eclipse RDF4J contributors.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Distribution License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*******************************************************************************/
```

RDF4J is on an 8-week release cycle for minor and major releases. See the [Milestone overview](https://github.com/eclipse/rdf4j/milestones) in the [issue tracker](https://github.com/eclipse/rdf4j/issues) for an overview of planned releases.
**NB** for older existing source code, RDF4J uses a slightly different
copyright header, mentioning 'Aduna' as additional copyright holder . Please
make sure you do not use that different header for any new contributions.

In order to guarantee stability of the release and to ensure we have enough
time to complete release review, we use a feature cutoff date. This date is
typically three weeks before the release date. The feature cutoff date does not
mean that each feature needs to be complete, but it does mean that we ask every
contributor to make a commitment to have their feature complete and stable in
time for final review and release. If a contributor cannot make that
commitment, the feature is not included in the release and is simply
"postponed" to the next release cycle.
- Qualified invocations exceeding the maximum line width are reformatted with the first method call on the same line, and each subsequent method call on its own line, indented.

We occasionally also schedule *patch releases*, which only include (backward
compatible) bug fixes. These releases are typically planned on short notice and
can be done without much in the way of formal review.
So, for example:

#### Release branches
```
return model.stream().map(st -> st.getObject()).filter(o -> o instanceof Literal).map(l -> (Literal) l).findAny();
```

A few days before release of a minor or major version, we create a *release
branch* from the current head of the master branch. The purpose of this release
branch is to perform last-minute tweaks and little fixes. Once we are ready to
release, the latest commit of the release branch is tagged with the version number, and
the release branch is merged back to master, then closed.
becomes:

## Code formatting
```
return model.stream()
.map(st -> st.getObject())
.filter(o -> o instanceof Literal)
.map(l -> (Literal) l)
.findAny();
```

RDF4J uses custom code formatting settings and a few code templates as well, and we expect every contributor to apply these settings before submitting a contribution.
There are various ways to apply these conventions to your code, depending on which editor/IDE you use.

The simplest way to do apply code formatting is as follows:
### Eclipse IDE users

1. In Eclipse, open 'Preferences' -> 'Java' -> 'Code Style' -> 'Formatter'
2. Click 'Import...' and find the file `eclipse-settings/rdf4j-formatting.xml`, located in the git repository root.
3. The active profile should now say 'RDF4J formatting'. Click ok.
2. Click 'Import...' and find the file `eclipse-settings/eclipse-rdf4j-conventions.xml`, located in the git repository root.
3. The active profile should now say 'Eclipse rdf4j '. Click ok.
4. When making changes to Java code, hit Ctrl+Shift+F before saving to reformat the code. Alternatively, you can configure Eclipse to automatically apply formatting on save. This can be activated by going to 'Preferences' -> 'Java' -> 'Editor' -> 'Save Actions' and making sure the 'Format source code' option checkbox is ticked.

Similarly, to apply templates:
Expand All @@ -115,22 +110,27 @@ Similarly, to apply templates:
2. Click 'Import...' and find the file `eclipse-settings/codetemplates.xml`, located in the git repository root.
3. Click OK. The templates will be automatically applied when necessary.

By the way: if you do not use Eclipse IDE, we still welcome your contributions
of course. We appreciate it if you make an effort to format your code to at least these
principles:
### Other IDEs / using the Maven formatter plugin

If you do not use Eclipse IDE, we still welcome your contributions of course. There are several ways in which you can configure your IDE to format according to our conventions. Some tools will have the Eclipse code conventions built in, or will have options to import Eclipse formatter settings.

In addition, the RDF4J project is configured to use the [formatter maven plugin](https://code.revelc.net/formatter-maven-plugin/) for validation of all code changes against the coding conventions.

To validate your changes manually, run the following command:

1. Use tabs only for indentation
2. Use unix newlines consistently
3. Use UTF-8 file encoding
4. Set line width to 110 characters
5. Make sure every new source file starts with the correct Eclipse copyright license header. The license header to use is:
```
/*******************************************************************************
* Copyright (c) 2016 Eclipse RDF4J contributors.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Distribution License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*******************************************************************************/
```
**NB** for older existing source code, RDF4J uses a slightly different copyright header, mentioning 'Aduna' as additional copyright holder . Please make sure you do not use that different header for any new contributions.
mvn formatter:validate
```

To reformat your code before committing, run:


```
mvn formatter:format
```

## Workflow

The short version for contributors: start from the `master` branch, and create a new, separate branch for every bugfix, improvement, or new feature.

For more detailed information on how RDF4J manages git branches, versioning, releases, and planning, see [Developer Workflow and Project Management](http://docs.rdf4j.org/developer/#_developer_workflow_and_project_management).
Empty file added .mvn/maven.config
View file
Empty file.
24 changes: 11 additions & 13 deletions README.md
View file
Original file line number Diff line number Diff line change
@@ -1,17 +1,15 @@
# Welcome to the RDF4J Storage repository

[![Build Status](https://travis-ci.org/eclipse/rdf4j-storage.svg?branch=master)](https://travis-ci.org/eclipse/rdf4j-storage)
This is the storage code repository for the Eclipse RDF4J project. It contains the SAIL API, database implementations, and various reasoners.

This is the storage code repository for the Eclipse RDF4J project. More code can be found in
* [rdf4j-client](https://github.com/eclipse/rdf4j) containing parsers and client libraries
* [rdf4j-tools](https://github.com/eclipse/rdf4j-tools) containing server and console
* [rdf4j-testsuite](https://github.com/eclipse/rdf4j-testsuite) containing common tests and benchmarks
Other components of RDF4J can be found in:
* [rdf4j](https://github.com/eclipse/rdf4j) containing client APIs (such as the Repository and Model API), RDF parsers and http client libraries
* [rdf4j-tools](https://github.com/eclipse/rdf4j-tools) containing the RDF4J Server, Workbench and Console applications
* [rdf4j-testsuite](https://github.com/eclipse/rdf4j-testsuite) containing common test suites and benchmarks

Please see [RDF4J.org](http://rdf4j.org) for detailed information about RDF4J, including
user documentation and [downloads of the latest release](http://rdf4j.org/download).

[![Visit our IRC channel](https://kiwiirc.com/buttons/irc.freenode.net/rdf4j.png)](https://kiwiirc.com/client/irc.freenode.net/?nick=rdf4j-user|?#rdf4j)

## Keen to contribute?

We welcome contributions! To get started, please first read our [Contributor
Expand All @@ -20,14 +18,14 @@ guidelines](https://github.com/eclipse/rdf4j/blob/master/.github/CONTRIBUTING.md
The short version:

1. Digitally sign the [Eclipse Contributor Agreement (ECA)](https://www.eclipse.org/legal/ECA.php). You can do this by logging into the [Eclipse projects forge](http://www.eclipse.org/contribute/cla); click on "Eclipse Contributor Agreement"; and Complete the form. Be sure to use the same email address when you register for the account that you intend to use on Git commit records. See the [ECA FAQ](https://www.eclipse.org/legal/ecafaq.php) for more info.
2. Create an issue in the [RDF4J GitHub issue tracker](https://github.com/eclipse/rdf4j/issues) that describes your improvement, new feature, or bug fix.
2. Create an issue in the [issue tracker](https://github.com/eclipse/rdf4j/issues) that describes your improvement, new feature, or bug fix.
3. Fork the GitHub repository.
4. Create a new branch (starting from master) for your issue.
5. Make your changes on this branch. Apply the [RDF4J code formatting guidelines](https://github.com/eclipse/rdf4j/blob/master/.github/CONTRIBUTING.md#code-formatting). Don't forget to include unit tests.
4. Create a new branch (starting from master) for your changes.
5. Make your changes on this branch. Apply the [RDF4J code formatting guidelines](https://github.com/eclipse/rdf4j-storage/blob/master/.github/CONTRIBUTING.md#code-formatting). Don't forget to include unit tests.
6. **sign off** every commit (using the `-s` flag).
7. Run `mvn verify` from the project root to make sure all tests succeed (both your own new ones, and existing).
8. Use meaningful commit messages and include the issue number in each commit message.
9. **sign off** every commit (using the `-s` flag).
10. Once your fix is complete, put it up for review by opening a Pull Request against the master branch in the central RDF4J repository.
9. Once your fix is complete, put it up for review by opening a Pull Request against the master branch in the central Github repository.

These steps are explained in more detail in the [Contributor
guidelines](https://github.com/eclipse/rdf4j/blob/master/.github/CONTRIBUTING.md).
guidelines](https://github.com/eclipse/rdf4j-storage/blob/master/.github/CONTRIBUTING.md).
Loading

0 comments on commit e6c1e56

Please sign in to comment.