Repository files navigation
All course commands and instructions below Section 1: Navigating a Commit History
diff -u game_new.js game_old.js // Show diffs between 2 files; -u is unified diff format == easier to read
// Lines with - sign were removed: in old version not new version
// Lines with + sign were added: in new version not old version
// Keep lines short //if all on one line, git would only show the lines are diff; not where in the line
git diff [older commit1] [newer commit2] // Compares 2 commits (alphanumeric strings)
commit //manual user-created checkpoint (think "file save") representing logical change to file
git log // show log, or history, of changes, i.e. commits, to filegit log --stat // Shows # changes to files; additions: green +; deletions: red -// Repository (repo): group of connected files, e.g. in same folder /allows tracking across multiple files /
git --version //self-explanatory; if not installed: https://www.udacity.com/wiki/ud775/install-git git clone https://github.com/udacity/asteroids.git // git clone: copies repo from URI to your local
// cd into /asteroids and run: git log
q //quits git log// Run diff command like earlier on two commits
git diff vs. diff -u // git diff tracks one files commit history; diff -u shows changes across filesgit checkout [commit id] // Temporarily resets all dir files to their state at time of this commit
detached HEAD // Occurs when checkout commit ID; git branch (below) easier; avoids thisHEAD // Current state you're in;
git checkout master // Get back to master branchscp // lets you copy directory from one computer to another
Section 2: Creating and Modifying a Repository
//git files stored in hidden folder: .git // view by typing ls -a
git init // Creates repository in pwd and subdirectoriesgit status // Shows which files have changed since last commit//git works like this: ||Working Directory || Staging Area || Repository
git add [filename(s)] // Adds to staging area; then git commit adds to repository
git reset // Removes file(s) from staging area; e.g. if accidentally added file.txtgit commit -m "type: subject body footer " // Best practice to write as a (present tense) commandgit diff // With no args shows changes between WD and Staging Areagit diff --staged // Shows changes in staged not committed yetgit reset --hard //Be very careful with this command; deletes all changes in WD too
Branches // Named labels for checking out commits (instead of commit ID)
// Once check out branch, remains checked out until merged
// Named to make easier on user (instead of alphanumeric commit ID) and avoid detached HEAD state
// multiple branches can be on same commit, but new commit only on checked out branch
git branch // Shows current branchesgit branch [new-name] // Creates new branchgit checkout [new-name] // Checks out branchgit log --graph --oneline [branch1] [branch2] [etc] // See sub-bullets
--graph // Shows commit tree;--oneline // Keeps output shorter and after you can specify branches to compare
git checkout -b new_branch_name // Creates new branch and checks out; fixes detached HEADgit gc // Git garbage collection; deletes unreachable commits from deleted branches
These commits are only accessible by commit ID until git gc runs
git merge [branch1] [branch2] // Merge branches
// Failed? Try: http://genomewiki.ucsc.edu/index.php/Resolving_merge_conflicts_in_Git
// And go into the file to see 3 sections:
// Top section: HEAD == your code
// Bottom section: master == code in master right now
// middle section: original version both sections modified, called: common ancestor
// Finally, resolve whichever change you want: delete git text inserted, e.g. HEAD ==== etc.
git merge --abort // Backs out of merge
git show commit_id // Compare commit to its parent
Section 3: Using Github to Collaborate
// Use password caching so don't have to type pwd every time commit to Github: https://help.github.com/articles/caching-your-github-password-in-git/
// Can't clone local repo to github; so you have to create "remote" repo in github, then push local up
// If creating new project on github (no local yet), create w/Readme...
Else if pushing locally, create remote without readme.md ...
because it counts readme as a commit && that creates conflict
git remote // View remotesgit remote add [name] [URL] // Add remote ; [name] can be anything but...
// e.g. git remote add origin [email protected] username /reponame
origin is common when have one remote
git remote -v // -v is 'verbose'; this command outputs github remotes`git push [remote name] [remote branch] // push local changes to remote
// e.g. git push origin master
// on github, clicking commits displays commits pushed to github; not all local
// e.g. if edit/create text files on github; pushed from another computer; pushed from another user
`git pull [remote name] [remote branch] // pull remote changes to sync to local
// e.g. git pull origin master
// fork : github copies a repo onto github in your account; then you clone (to local)
// Click fork button upper right
// Copy new forked repo URL middle-right on page
git clone [new-forked-URL]
// remote auto-established: i.e. cd to new folder locally; git remote -v displays URL
// Add collaborator in settings to enable them to be able to push to your repository
git fetch [origin] // useful when changes locally and remotely differ; fetch remote
// creates new branch locally enabling git diff to compare changes on local and remote repos
// Locally, you can now combine origin/master and master, which is same as git pull
// e.g. `git fetch origin' updates every local branch of origin/master
// then git log origin master or git diff origin/master master
git pull origin master // will fetch and then merge local master and remote i.e origin/master// Fast-forward merge: when taking an ancestor's label and moving to head
// Make change locally on change branch off master
// Push to change branch on github
// Then use github feature-- pull requests -- to allow repo owner to see change(s) and comment
// e.g. if changing oil type in a recipe:
git branch diff-oil // Create new branchgit checkout diff-oil // Checkout new branch, then make the change to sourcegit add recipe.txt // Add to repogit commit // commit the filegit push origin diff-oil // Push to github // on github, you can click on branch to see commits// now, either click Compare & Pull Request button if haven't compared, or pull request
// Click edit if need to change the base fork into which you are merging your changes
// Scroll down to right and click Create Pull Request button
// Reviewer can merge or leave a comment if more revisions desired
// Dev can then revise and run git push origin master
// github will auto reflect the change in revisions
// Practice: create diff-oil branch; commit diff-oil; push diff-oil to your fork; pull request diff-oil into master
// Repo owner: review change, if accept, click confirm to pull request and merge; then delete branch;
// btw, pressing button on github always commits even if no extra info given by that merge commit
// But...can't merge a branch into master if conflicts
// Github requires you to pull changes to your local version
// You could just merge locally, then push to origin master but that obviates owner having chance to review, so update branch then push
// If don't see latest changes locally when run git log then run git fetch to examine changes then git merge origin/master master
// Making changes in a separate branch is more complicated than working directly in master,
// especially when you need to stay up-to-date with changes others are making.
// Rather than simply pulling and pushing, you need to pull changes into your local master branch,
// Merge the local master into your branch (different-oil, in our case),
// Then push your branch to the remote before finally merging your branch into master, either locally or on GitHub.
// Practice:
// Fork this: https://github.com/udacity/create-your-own-adventure
// Clone it
// Make branch to make changes
// "pull request" from your branch, leave original as base
// follow README on github repo to have requets merged
// If there is a merge conflict, some steps to take:
a. // E.g. Fork original, then clone it (to local), make change locally, then push to remote fork...
b. // Meantime...someone else changes original master on github and may find your pull request can't be merged b/c of conflicts
c. // Need to resolve locally--i.e. get conflicting changes from original--by adding new remote.
d. // Already have remote origin which points to fork, so need to set up new remote to original:
1. // Call the new one upstream/master // common practice to name that way and add and fetch upstream
* git remote add upstream https://github.com/udacity/create-your-own-adventure.git
* git checkout master
2. // Run git pull upstream/master
2. // Then locally merge upstream/master into local change branch: git merge master my-branch-name
3. // Then push master and change branch to my fork: git push origin my-clone-branch // origin is my fork
4. git checkout master
5. `git push
6. // Now should have option to merge pull request
e.
You can’t perform that action at this time.
