Page Comparison

The information below pertains to developers and other coding enthusiasts who would like to set up a running instance of the Open Library Environment project from Github (https://github.com/openlibraryenvironment/ole.get).

Step-by-step guide

Checkout OLE code from github
1. Create a local workspace where you would want to checkout the OLE codebase
clone the remote repository by issuing the following command:
2. 1. The very first thing one should do is to fork the main repository. This assumes you have a github user account.
      1. git clone https://github.com/
openlibraryenvironment
3. 1. 1. user/ole.git
4. Once its cloned, you will see a folder with the name "ole" created. 
Switch to the appropriate branchCheck which branch is active in your local repository by issuing the following command:
5. 1. 1.  [Note this is the url of your forked repository]
      2. Switch to the newly created folder (OLE if it exists or to the directory where the OLE base files were cloned to) and do the following;
         1. List all the branches by using git branch -a
         2. One of the listed entries should have an
* next
6. 1. 1. 1. astreix  next to it indicating that is the current active branch
currently
7. 1. 1. 1. on your local
box.
8. You will need to switch to the "develop" branch. As a best practice, we push our changes to the develop branch.
   1. Issue the following command to switch to the develop branch: git checkout develop
9. Launch your favorite IDE and start OLE (IntelliJ IDEA instructions- coming soon!)
10. Ongoing Development
    1. Fork your copy
       1. git clone https://github.com/user/ole.git
    2. Make changes to your local copy
       1. List all the branches by using git checkout -a
       2. Switch to develop branch by using git checkout develop. This is to ensure when pull requests are created, they will be against the develop branch in the main repository.
          
          1. For more granularity, you can create feature branches and work on those feature branches.
          2. Create a feature branch by using git branch "feature or issue name"
          3. Switch to the new feature branch by using git checkout "feature or issue name"
    3. Push changes to your forked repository
       1. You can work on changes, commit and push the changes to your own public repository. The command to use would be git commit -m "some message" followed by git push origin develop. Alternatively you could you use your favorite IDE to push your changes to your public repository.
    4. Create a pull request
       1. You can visit github.com and go to the ole repository under your username. 
       2. Click on the pull request button to initiate a pull request.
       3. Once a pull request is created, one of the core committers will review and merge the changes to the main line. 
11. Core Committers
    1. Review pull requests
       1. Direct Diff
       2. Fetch changes locally
          1. Review
          2. Merge
          3. Push
12. 1. 1. 1. machine. By default it is master branch.
          2. Switch to develop branch by using git checkout develop. The OLE core team works on develop branch and so if you need to create any pull requests, its better to be on the same branch as the main ole repository's active development line.
       2. Making changes to your local copy of OLE
          1. Once changes have been authored to your local copy of OLE you can commit and push your changes up to your public repository by doing the following; (Alternatively, you could you use your favorite IDE to commit & push changes to your local repository);
             1. commit: git commit -m "custom message" 
             2. push: git push origin develop
    2. Creating a Pull Request
       1. Once you have pushed your changes to your public repository, you can create a "Pull Request" to notify the core team of your intention to either contribute or get your code merged (other team developers). 
          1. On Github, under your repository, switch to develop branch and then you can click the green button "Pull Request", add comments and create the request. 
          2. Once the Pull Request is created, the core team is notified of your intentions, and someone will review and merge as appropriate.
    3. Core Committers/Reviewers
       1. Review/Merge/Fetch changes by someone else
          1. Fetch changes locally first
             1. Review: In order to fetch someone else's changes, first you need to add the public url of the person's repository whose changes you would like to fetch
                1. Switch to your forked workspace
                2. git fetch "url of the team/contributor's public OLE url" branch name (develop in our case)
                   1. Example: git fetch https://github.com/peris/ole.git develop
             2. Switch to the appropriate branch (develop in our case)
                1. git checkout develop (or any other active branch that you would want the merge into)
                   
                2. git merge FETCH_HEAD
             3. Push: Once you have merged the changes, verified, you can commit and push to your public repository. And follow 1b.
    4. Keeping your public repository in sync with the main line.
       1. When you are working on your forked copy of OLE, you would want to keep it in sync with the main develop branch
       2. First you will need to add the remote/develop by using git remote add upstream https://github.com/openlibraryenvironment/ole.git
       3. Sync the changes to your local copy by using git pull upstream develop (develop is the branch that you are syncing your local copy with)
       4. Once the local repository is in sync, you can continue working on your changes and push them to your public repository when appropriate. 
       5. Follow 2.b if needed.

Related articles