refactor

Author: jgrynczewski

.github/workflows/labs.yml

@@ -31,8 +31,8 @@ jobs:
           cd 0_intro/01_hello
           pytest -v --tb=short
 
-  lab-02-solid-srp:
-    name: "Lab 02 - SOLID: SRP (10 pts)"
+  lab-02-grasp-coupling:
+    name: "Lab 02 - GRASP: Low Coupling (10 pts)"
     runs-on: ubuntu-latest
 
     steps:
@@ -51,11 +51,11 @@ jobs:
 
       - name: Run Lab 02 tests
         run: |
-          cd 1_principles/01_solid/01_srp
+          cd 1_principles/01_grasp/04_low_coupling
           pytest -v --tb=short
 
-  lab-03-grasp-expert:
-    name: "Lab 03 - GRASP: Expert (10 pts)"
+  lab-03-solid-ocp:
+    name: "Lab 03 - SOLID: OCP (10 pts)"
     runs-on: ubuntu-latest
 
     steps:
@@ -74,14 +74,14 @@ jobs:
 
       - name: Run Lab 03 tests
         run: |
-          cd 1_principles/02_grasp/01_information_expert
+          cd 1_principles/02_solid/02_ocp
           pytest -v --tb=short
 
   # Summary job - pokazuje ogólny status
   summary:
     name: "Summary"
     runs-on: ubuntu-latest
-    needs: [lab-01-intro-hello, lab-02-solid-srp, lab-03-grasp-expert]
+    needs: [lab-01-intro-hello, lab-02-grasp-coupling, lab-03-solid-ocp]
     if: always()
 
     steps:
@@ -91,6 +91,6 @@ jobs:
           echo "Design Patterns Workshop - Test Summary"
           echo "============================================"
           echo "Lab 01 - Intro Calculator: ${{ needs.lab-01-intro-hello.result }}"
-          echo "Lab 02 - SOLID SRP: ${{ needs.lab-02-solid-srp.result }}"
-          echo "Lab 03 - GRASP Expert: ${{ needs.lab-03-grasp-expert.result }}"
+          echo "Lab 02 - GRASP Low Coupling: ${{ needs.lab-02-grasp-coupling.result }}"
+          echo "Lab 03 - SOLID OCP: ${{ needs.lab-03-solid-ocp.result }}"
           echo "============================================"

0_intro/01_hello/README.md

@@ -1,39 +1,40 @@
-# 👋 Intro - Simple Calculator
+# 👋 Intro - Prosty Kalkulator
 
-**Difficulty**: very easy  
-**Time**: 5 minutes  
-**Focus**: Setup verification
+**Poziom**: bardzo łatwy  
+**Cel**: Weryfikacja środowiska
 
 ## 🎯 Zadanie
 Zaimplementuj dwie proste funkcje, żeby sprawdzić, że środowisko działa poprawnie.
 
 ## 📋 Wymagania
-- [ ] `add(2, 3)` zwraca `5`
-- [ ] `add(10, 5)` zwraca `15`
-- [ ] `multiply(2, 3)` zwraca `6`
-- [ ] `multiply(10, 5)` zwraca `50`
-- [ ] Funkcje działają z liczbami ujemnymi i zerem
+- [ ] Przechodzą doctesty
+- [ ] Przechodzą testy jednostkowe (pytest)
+- [ ] Funkcje działają z liczbami dodatnimi, ujemnymi i zerem
 
 ## 🚀 Jak zacząć
 1. Otwórz `starter.py`
-2. Uruchom doctests: `python -m doctest starter.py -v`
+2. Uruchom testy (powinny failować):
+   - Doctests: `python -m doctest starter.py -v`
+   - Pytest: `pytest` (lub `pytest -v` dla bardziej szczegółowego outputu)
 3. Zaimplementuj funkcje `add()` i `multiply()`
-4. Uruchom testy: `python -m pytest test_hello.py -v`
-5. Commit gdy wszystkie testy przechodzą ✅
+4. Uruchom testy ponownie (teraz powinny przejść)
+5. Gdy wszystkie testy przechodzą:
+   ```bash
+   git add .
+   git commit -m "Complete Lab 01 - Calculator"
+   git push
+   ```
+6. Sprawdź wynik w GitHub:
+   - Wejdź w zakładkę **Actions** w swoim repo
+   - Znajdź job "Lab 01 - Intro: Calculator"
+   - ✅ Zielony = zadanie zaliczone!
 
 ## 💡 Podpowiedź
-- Sprawdź doctests w `starter.py` - pokazują expected behavior
+- Sprawdź doctests w `starter.py` - pokazują oczekiwane zachowanie
 - `add(a, b)` powinno zwrócić sumę: `a + b`
 - `multiply(a, b)` powinno zwrócić iloczyn: `a * b`
 
-## ✅ Success criteria
-Gdy uruchomisz:
-```bash
-    python -m doctest starter.py -v
-    python -m pytest test_hello.py -v
-```
+## ✅ Kryteria sukcesu
+Wszystkie testy przechodzą (zielone ✅).
 
-Wszystkie testy powinny być zielone ✅
-
-Jeśli wszystkie testy przeszły, Twoje środowisko działa poprawnie.
-🎉 Gratulacje!
+Jeśli tak, środowisko działa poprawnie. 🎉

1_principles/01_grasp/04_low_coupling/README.md

@@ -0,0 +1,57 @@
+# 🔗 GRASP Low Coupling - System Gry
+
+**Poziom**: łatwy
+**Cel**: GRASP Low Coupling
+
+## 🎯 Zadanie
+Zaimplementuj `Game` i `ScoreService` (pośrednika), aby zredukować sprzężenie między `Game` a `Database`.
+
+## 📋 Wymagania
+- [ ] Przechodzą doctesty
+- [ ] Przechodzą testy jednostkowe (pytest)
+- [ ] `Game` używa `ScoreService` jako pośrednika (nie zna `Database`)
+
+## 🚀 Jak zacząć
+1. Otwórz `starter.py`
+2. Uruchom testy (powinny failować):
+   - Doctests: `python -m doctest starter.py -v`
+   - Pytest: `pytest` (lub `pytest -v` dla bardziej szczegółowego outputu)
+3. Zaimplementuj klasę `ScoreService`
+4. Zaimplementuj klasę `Game` z dependency injection
+5. Uruchom testy ponownie (teraz powinny przejść)
+6. Gdy wszystkie testy przechodzą:
+   ```bash
+   git add .
+   git commit -m "Complete Lab XX - Low Coupling"
+   git push
+   ```
+7. Sprawdź wynik w GitHub Actions
+
+## 💡 GRASP Low Coupling w pigułce
+
+**Minimalizuj zależności między klasami**
+
+❌ **Źle** (silne sprzężenie):
+```python
+class Game:
+    def finish_game(self, player, score):
+        db = Database()  # Bezpośrednia zależność ❌
+        db.connect()
+        db.save(player, score)
+        # Game zna szczegóły Database - silne sprzężenie
+```
+
+✅ **Dobrze** (luźne sprzężenie):
+```python
+class Game:
+    def __init__(self, score_service):  # Pośrednik ✅
+        self.score_service = score_service
+
+    def finish_game(self, player, score):
+        self.score_service.save_score(player, score)
+        # Game nie zna Database - luźne sprzężenie
+
+# ScoreService izoluje Game od Database
+```
+
+**Korzyść**: Zmiana Database nie wpływa na Game. Łatwe testowanie (mock ScoreService).

1_principles/01_grasp/04_low_coupling/starter.py

@@ -0,0 +1,55 @@
+"""
+GRASP Low Coupling - Game System
+
+>>> # Test ScoreService
+>>> service = ScoreService()
+>>> service.save_score("player1", 100)
+'Saved score 100 for player1'
+
+>>> # Test Game with ScoreService (low coupling)
+>>> game = Game(service)
+>>> game.finish_game("Alice", 150)
+'Game finished. Saved score 150 for Alice'
+"""
+
+
+class Database:
+    """Konkretna implementacja bazy danych"""
+
+    def connect(self) -> str:
+        return "Connected to database"
+
+    def save(self, player: str, score: int) -> str:
+        return f"Saved score {score} for {player}"
+
+
+# TODO: Zaimplementuj ScoreService
+# Klasa pośrednicząca między Game a bazą danych (redukuje sprzężenie)
+# Metoda save_score(player, score) zwraca: "Saved score {score} for {player}"
+
+class ScoreService:
+    pass
+
+
+# TODO: Zaimplementuj Game
+# Przyjmuje score_service: ScoreService w konstruktorze (dependency injection)
+# Metoda finish_game(player, score):
+#   - Wywołuje score_service.save_score(player, score)
+#   - Zwraca "Game finished. {wynik z save_score}"
+#
+# Low Coupling: Game nie zna Database, tylko ScoreService (pośrednik)
+
+class Game:
+    pass
+
+
+# GRASP Low Coupling:
+# Minimalizuj zależności między klasami
+#
+# Silne sprzężenie ❌:
+# Game → Database (bezpośrednia zależność)
+#
+# Luźne sprzężenie ✅:
+# Game → ScoreService → Database (pośrednik)
+#
+# Korzyść: Zmiana Database nie wpływa na Game

1_principles/02_grasp/04_low_coupling/test_coupling.py renamed to 1_principles/01_grasp/04_low_coupling/tests.py

@@ -0,0 +1,102 @@
+"""
+❌ VIOLATION of GRASP Low Coupling
+
+Problem: Game bezpośrednio zależy od Database
+- Silne sprzężenie - Game "wie" o szczegółach bazy danych
+- Zmiana Database wymaga modyfikacji Game
+- Trudne testowanie - nie można łatwo zamockować Database
+- Naruszenie Low Coupling: zbyt wiele zależności między klasami
+"""
+
+
+class Database:
+    """
+    Konkretna implementacja bazy danych
+
+    UWAGA: Użyj tej klasy w ScoreService, NIE w Game!
+    Game powinien znać tylko ScoreService (pośrednika)
+    """
+
+    def connect(self) -> str:
+        return "Connected to database"
+
+    def save(self, player: str, score: int) -> str:
+        return f"Saved score {score} for {player}"
+
+
+class Game:
+    """
+    ❌ PROBLEM: Bezpośrednia zależność od Database
+
+    Konsekwencje:
+    1. Silne sprzężenie - Game musi znać Database
+    2. Trudne testowanie - wymaga prawdziwej bazy lub użycia patcha
+    3. Zmiana Database = zmiana Game
+    4. Game odpowiada za logikę gry ORAZ komunikację z bazą
+    """
+
+    def finish_game(self, player: str, score: int) -> str:
+        """
+        ❌ Tworzy Database bezpośrednio w metodzie
+        """
+        # ❌ PROBLEM: Bezpośrednie tworzenie Database
+        # Game "wie" o Database - silne sprzężenie
+        db = Database()
+
+        # ❌ PROBLEM: Game zna szczegóły implementacji Database
+        # Musi wiedzieć że trzeba najpierw connect(), potem save()
+        result = db.connect()
+        result += "\n" + db.save(player, score)
+
+        return f"Game finished.\n{result}"
+
+
+# ❌ Przykład użycia - działa, ale narusza Low Coupling
+if __name__ == "__main__":
+    game = Game()
+    print(game.finish_game("Alice", 150))
+
+    # ❌ Chcę przetestować Game bez prawdziwej bazy?
+    # Nie mogę - Game tworzy Database bezpośrednio w finish_game() (ew. patch)
+    #
+    # ❌ Chcę zmienić Database na inną implementację?
+    # Muszę EDYTOWAĆ Game.finish_game()
+    #
+    # ❌ Chcę dodać cache między Game a Database?
+    # Muszę EDYTOWAĆ Game - nie ma miejsca na pośrednika
+    #
+    # To naruszenie Low Coupling!
+
+
+"""
+Dlaczego to jest ZŁE?
+
+1. ❌ Silne sprzężenie
+   - Game bezpośrednio zależy od Database
+   - Game musi znać szczegóły Database (connect, save)
+   - Trudno zmienić implementację
+
+2. ❌ Trudne testowanie
+   - Nie można wstrzyknąć mock Database, trzeba patchować
+   - Trudno testować Game w izolacji
+
+3. ❌ Brak elastyczności
+   - Nie można dodać pośrednika (cache, logger)
+   - Zmiana Database wymaga zmiany Game
+   - Naruszenie Open/Closed
+
+4. ❌ Naruszenie Single Responsibility
+   - Game odpowiada za logikę gry
+   - Game odpowiada za komunikację z bazą
+   - Dwie odpowiedzialności w jednej klasie
+
+5. ❌ Wysokie sprzężenie = niska "współużywalność"
+   - Game nie może działać bez Database
+   - Nie można użyć Game z innym storage (file, API)
+
+Jak to naprawić?
+1. Stwórz ScoreService jako pośrednika
+2. Game przyjmuje ScoreService w konstruktorze (dependency injection)
+3. ScoreService izoluje Game od Database
+4. Game nie zna szczegółów Database - tylko wywołuje score_service.save_score()
+"""