t2.9/z1.txt

z1
Pewnie! Poniżej masz zwięzłe, „dla ucznia” instrukcje do tematu **2.2 Podstawy Gita – rejestrowanie zmian w repozytorium**. To jest gotowa ściąga + scenariusz ćwiczenia krok-po-kroku.

# 2.2 Rejestrowanie zmian w Git

## Cel

Nauczysz się:

* sprawdzać stan repozytorium,
* dodawać pliki do „poczekalni” (staging area),
* zatwierdzać (commitować) zmiany,
* ignorować niepotrzebne pliki,
* usuwać/zmieniać nazwy plików w projekcie pod kontrolą Gita,
* przeglądać różnice (diff) tego, co **poza** i **w** poczekalni.

---

## Słowniczek (bardzo krótko)

* **Śledzony (tracked)** – plik był w ostatnim commicie. Może być: niezmodyfikowany, zmodyfikowany, albo w poczekalni.
* **Nieśledzony (untracked)** – plik nowy dla Gita (nie był w ostatnim commicie).
* **Poczekalnia (staging area / index)** – lista zmian, które **wejdą do najbliższego commita**.
* **Commit** – zapisana migawka projektu z opisem.

---

## Najważniejsze polecenia (z przykładami)

### 1) Sprawdź status

```bash
git status
```

* Pokazuje gałąź, pliki **nieśledzone**, **zmodyfikowane** i **w poczekalni**.

### 2) Zacznij śledzić plik / dodaj do poczekalni

```bash
git add README            # pojedynczy plik
git add .                 # wszystko z bieżącego katalogu (ostrożnie)
```

### 3) Zobacz różnice

* **Zmiany poza poczekalnią**:

```bash
git diff
```

* **Zmiany w poczekalni (wejdą do commita)**:

```bash
git diff --staged     # to samo co: git diff --cached
```

### 4) Zatwierdź zmiany (commit)

```bash
git commit            # otworzy edytor do wpisania wiadomości
git commit -m "Krótki, rzeczowy opis zmiany"
```

### 5) Pomiń poczekalnię dla śledzonych plików

> Działa **tylko** dla plików już śledzonych.

```bash
git commit -a -m "Szybki commit bez ręcznego git add"
```

### 6) Cofnij dodanie do poczekalni / porzuć zmiany w pliku

```bash
git reset HEAD <plik>     # wyjmij plik z poczekalni (zostają zmiany na dysku)
git checkout -- <plik>    # porzuć zmiany w pliku i przywróć wersję z HEAD
```

### 7) Ignoruj pliki – `.gitignore`

Utwórz plik `.gitignore` w katalogu projektu:

```gitignore
# przykłady:
*.o
*.a
*~
/TODO
build/
doc/*.txt
doc/**/*.txt
```

Zasady:

* `#` – komentarz
* `*` – dowolny ciąg znaków, `?` – jeden znak, `[abc]` – zestaw znaków
* `/` na końcu – katalog
* `!wzorzec` – zanegowanie (wyjątek od reguły)

### 8) Usuń plik z repo (i z dysku)

```bash
git rm PROJECTS.md
git commit -m "Usuń PROJECTS.md"
```

* Jeśli plik był już w poczekalni po modyfikacji – użyj `git rm -f`.

**Zostaw plik na dysku, ale przestań śledzić:**

```bash
git rm --cached duzy.log
```

### 9) Zmień nazwę/przenieś plik

```bash
git mv stara_nazwa nowa_nazwa
# równoważne ręcznie:
# mv stara_nazwa nowa_nazwa && git rm stara_nazwa && git add nowa_nazwa
```

---

## „Zwięzły status” – szybka legenda

```bash
git status -s
```

Przykład:

```
 M README           # M po prawej: zmieniony w katalogu roboczym
M  lib/simplegit.rb # M po lewej: zmiana jest w poczekalni
A  lib/git.rb       # A w poczekalni (nowy plik dodany)
?? LICENSE.txt      # plik nieśledzony
```

Dwukolumnowo: **lewa** = poczekalnia, **prawa** = katalog roboczy.

---

## Rekomendowany workflow (bezpieczny)

1. **Sprawdź status**: `git status`
2. **Obejrzyj różnice**: `git diff`
3. **Dodaj do poczekalni** konkretne pliki: `git add <plik>`
4. **Sprawdź co wejdzie**: `git diff --staged`
5. **Commit** z sensownym opisem: `git commit -m "…"`
6. **Powtórz** po kolejnych zmianach.

> Uwaga: jeżeli edytowałeś plik **po** `git add`, dodaj go **ponownie** (`git add <plik>`), inaczej commit nie uwzględni ostatniej poprawki!

---

## Najczęstsze błędy i szybkie naprawy

* „Commit nic nie zawiera” → zapomniałeś `git add`. Dodaj i powtórz.
* „Plik w poczekalni i jednocześnie zmodyfikowany” → dodałeś go, a potem znów zmieniłeś. Użyj:

  * `git diff` (co jest **poza** poczekalnią),
  * `git diff --staged` (co **wejdzie** do commita),
  * i **ponownie** `git add <plik>`.
* „Przez pomyłkę dodałem śmieci” → dodaj do `.gitignore`, a plik wyjmij ze śledzenia: `git rm --cached <plik>`.

---

## Mini-ćwiczenie (15–20 min)

1. **Przygotuj repo**

```bash
git init git-lesson
cd git-lesson
echo "Witaj Git!" > README.md
git add README.md
git commit -m "Inicjalny commit z README"
```

2. **Dodaj nowy plik i przećwicz statusy**

```bash
echo "Zasady" > RULES.md
git status          # zobaczysz ?? RULES.md
git add RULES.md
git status -s       # powinno pokazać A  RULES.md
git commit -m "Dodaj RULES.md"
```

3. **Modyfikacje + poczekalnia**

```bash
echo "Linia A" >> README.md
git diff            # zobaczysz różnice poza poczekalnią
git add README.md
git diff --staged   # zobaczysz różnice, które wejdą do commita
git commit -m "Uzupełnij README o Linię A"
```

4. **Zmiany po dodaniu do poczekalni**

```bash
echo "Linia B" >> README.md
git status          # README pojawi się jednocześnie w staged i modified
git add README.md   # dołóż najnowsze zmiany do poczekalni
git commit -m "Dodaj Linię B do README"
```

5. **.gitignore**

```bash
echo "*.log" > .gitignore
echo "debug.log" > debug.log
git status          # debug.log powinien być ignorowany
git add .gitignore
git commit -m "Dodaj regułę ignorowania *.log"
```

6. **Usuwanie i zmiana nazwy**

```bash
git rm RULES.md
git commit -m "Usuń plik RULES.md"

git mv README.md README
git commit -m "Zmień nazwę README.md -> README"
```

> Na koniec `git log --oneline` – sprawdź historię swoich commitów.

---

## Krótka ściąga (do druku)

* **Stan**: `git status` / `git status -s`
* **Różnice**: `git diff` (poza poczekalnią), `git diff --staged` (wejdą do commita)
* **Dodanie**: `git add <plik>` / `git add .`
* **Commit**: `git commit -m "Opis"` / `git commit -a -m "Opis"` (tylko śledzone)
* **Wyjęcie z poczekalni**: `git reset HEAD <plik>`
* **Porzucenie zmian w pliku**: `git checkout -- <plik>`
* **Ignorowanie**: `.gitignore`
* **Usuwanie**: `git rm <plik>` / `git rm --cached <plik>`
* **Zmiana nazwy**: `git mv stara nowa`

Chcesz, żebym przerobił to na jedną stronę A4 (PDF) dla uczniów z miejscem na odhaczenie kroków i mini-quiz na końcu?