Pushing and Pulling Code

Hands-On Exercise: Mastering Push and Pull

Let's practice pushing and pulling with a simple Python project. We'll simulate a collaborative environment where multiple team members are working together.

Exercise Setup

1. Create a new repository on GitHub
   • Name: "python_calculator"
   • Description: "A simple calculator implemented in Python"
   • Initialize with a README
   • Add a .gitignore for Python
   • Choose an open-source license (e.g., MIT)
2. Clone the repository locally
   $ git clone git@github.com:your-username/python_calculator.git $ cd python_calculator

Part 1: Basic Push and Pull

1. Create a basic calculator module
   $ touch calculator.py

   Add the following code to calculator.py:

   def add(a, b): """Add two numbers and return the result.""" return a + b def subtract(a, b): """Subtract b from a and return the result.""" return a - b
2. Add a test file
   $ touch test_calculator.py

   Add the following code to test_calculator.py:

   import unittest from calculator import add, subtract class TestCalculator(unittest.TestCase): def test_add(self): self.assertEqual(add(2, 3), 5) self.assertEqual(add(-1, 1), 0) def test_subtract(self): self.assertEqual(subtract(5, 3), 2) self.assertEqual(subtract(1, 1), 0) if __name__ == '__main__': unittest.main()
3. Stage, commit, and push the changes
   $ git add calculator.py test_calculator.py $ git commit -m "feat: Add basic calculator with add and subtract functions" $ git push
4. Simulate a change on the remote

   Go to GitHub, edit the README.md file directly on the website. Add some basic documentation:

   # Python Calculator A simple calculator implemented in Python. ## Features - Addition - Subtraction ## Usage ```python from calculator import add, subtract result = add(5, 3) # Returns 8 result = subtract(5, 3) # Returns 2 ``` ## Testing Run the tests with: ``` python -m unittest test_calculator.py ```

   Commit these changes directly on GitHub.

5. Pull the remote changes
   $ git pull

   Observe how Git pulls and integrates the README changes.

Part 2: Feature Branches and Collaboration

1. Create a feature branch for multiplication
   $ git checkout -b feature/multiplication
2. Add multiplication functionality

   Update calculator.py to add a multiply function:

   def add(a, b): """Add two numbers and return the result.""" return a + b def subtract(a, b): """Subtract b from a and return the result.""" return a - b def multiply(a, b): """Multiply two numbers and return the result.""" return a * b

   Also update test_calculator.py:

   import unittest from calculator import add, subtract, multiply class TestCalculator(unittest.TestCase): def test_add(self): self.assertEqual(add(2, 3), 5) self.assertEqual(add(-1, 1), 0) def test_subtract(self): self.assertEqual(subtract(5, 3), 2) self.assertEqual(subtract(1, 1), 0) def test_multiply(self): self.assertEqual(multiply(2, 3), 6) self.assertEqual(multiply(-1, 5), -5) if __name__ == '__main__': unittest.main()
3. Commit and push the feature branch
   $ git add calculator.py test_calculator.py $ git commit -m "feat: Add multiplication function" $ git push -u origin feature/multiplication
4. Create another feature branch for division
   $ git checkout main $ git checkout -b feature/division
5. Add division functionality

   Update calculator.py to add a divide function:

   def add(a, b): """Add two numbers and return the result.""" return a + b def subtract(a, b): """Subtract b from a and return the result.""" return a - b def divide(a, b): """Divide a by b and return the result.""" if b == 0: raise ValueError("Cannot divide by zero") return a / b

   Also update test_calculator.py:

   import unittest from calculator import add, subtract, divide class TestCalculator(unittest.TestCase): def test_add(self): self.assertEqual(add(2, 3), 5) self.assertEqual(add(-1, 1), 0) def test_subtract(self): self.assertEqual(subtract(5, 3), 2) self.assertEqual(subtract(1, 1), 0) def test_divide(self): self.assertEqual(divide(6, 3), 2) self.assertEqual(divide(1, 1), 1) with self.assertRaises(ValueError): divide(1, 0) if __name__ == '__main__': unittest.main()
6. Commit and push the division branch
   $ git add calculator.py test_calculator.py $ git commit -m "feat: Add division function with zero check" $ git push -u origin feature/division

Part 3: Merging and Handling Conflicts

1. Merge the multiplication branch into main
   $ git checkout main $ git merge feature/multiplication $ git push
2. Try to merge the division branch (this will cause a conflict)
   $ git merge feature/division

   This will likely result in a merge conflict in calculator.py and test_calculator.py

3. Resolve the conflicts
   $ code calculator.py $ code test_calculator.py

   Edit the files to resolve conflicts, keeping both multiplication and division functionality. The final calculator.py should look like:

   def add(a, b): """Add two numbers and return the result.""" return a + b def subtract(a, b): """Subtract b from a and return the result.""" return a - b def multiply(a, b): """Multiply two numbers and return the result.""" return a * b def divide(a, b): """Divide a by b and return the result.""" if b == 0: raise ValueError("Cannot divide by zero") return a / b

   And test_calculator.py should include tests for all functions:

   import unittest from calculator import add, subtract, multiply, divide class TestCalculator(unittest.TestCase): def test_add(self): self.assertEqual(add(2, 3), 5) self.assertEqual(add(-1, 1), 0) def test_subtract(self): self.assertEqual(subtract(5, 3), 2) self.assertEqual(subtract(1, 1), 0) def test_multiply(self): self.assertEqual(multiply(2, 3), 6) self.assertEqual(multiply(-1, 5), -5) def test_divide(self): self.assertEqual(divide(6, 3), 2) self.assertEqual(divide(1, 1), 1) with self.assertRaises(ValueError): divide(1, 0) if __name__ == '__main__': unittest.main()
4. Complete the merge and push
   $ git add calculator.py test_calculator.py $ git commit $ git push
5. Update the README on GitHub

   Go to GitHub and update the README.md to include the new functions, then pull these changes:

   $ git pull

Part 4: Advanced Push and Pull Operations

1. Create a power function in a new branch
   $ git checkout -b feature/power

   Add a power function to calculator.py:

   def power(a, b): """Raise a to the power of b and return the result.""" return a ** b

   And add a test to test_calculator.py.

2. Commit the changes
   $ git add calculator.py test_calculator.py $ git commit -m "feat: Add power function"
3. Simulate remote changes by asking a partner to edit main

   If you're working alone, use GitHub's web interface to edit a file in the main branch, such as adding a comment or improving documentation.

4. Use rebase to integrate main changes
   $ git checkout main $ git pull $ git checkout feature/power $ git rebase main
5. Push with force-with-lease after rebase
   $ git push --force-with-lease origin feature/power