1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
|
---
redirect_from: "/How-to-create-a-PR"
---
# Como crear una PR
Esta guía explica cómo abrir PRs para enviar cualquier tipo de correciones (C++, SQL, etc...).
Si sólo envías correcciones de DB, deberías probar nuestra nueva [simplificada manera de abrir una PR que contenga código SQL](https://www.azerothcore.org/wiki/how-to-create-a-db-pr).
## Hacer sólo UNA VEZ: crear y clonar tu fork de AzerothCore
### 1. Crear un fork de AzerothCore
Necesitas estar registrado en [github.com](https://github.com/). Si aun no tienes una cuenta, crea una.
Abre el [repositorio de AzerothCore](https://github.com/azerothcore/azerothcore-wotlk)
Y crea un fork de este haciendo click en el botón "Fork" de arriba a la derecha:
### 2. Clona tu fork a tu dispositivo local
Una vez que tu fork esté listo, verás un nuevo repositorio mostrando **YourUsername/azerothcore-wotlk**.
Haz click en el botón "Clone or download" (a la derecha) y copia la dirección https de tu fork:
Ahora abre la **terminal** (si estas en Windows, usa [terminal git bash](https://git-scm.com/downloads))
y escribe `git clone ` seguido de la dirección de tu fork que acabas de copiar:
```
git clone https://github.com/YourUsername/azerothcore-wotlk.git
```
Espera a que la descarga termine y luego accede al directorio de `azerothcore-wotlk`:
```
cd azerothcore-wotlk
```
## Creando una nueva PR
### 1. Actualiza tu fork en GitHub
Abre tu navegador y navega hasta tu fork en GitHub (cambia `YourUsername` con tu usuario actual de GitHub):
**https://github.com/YourUsername/azerothcore-wotlk**
Si tu `master` branch no está actualizado a la última versión de AzerothCore, verás algo como:
`This branch is XX commits behind azerothcore:master`
para actualizarlo, haz click en **Fetch upstream** y luego **Fetch and merge**.
Como resultado, el `master` branch de tu fork debería directorio:
`This branch is even with azerothcore:master`
### 2. Actualiza tu clone local
En el anterior paso acabas de actualizar tu fork *remoto*, pero también tienes que sincronizarlo con tu clon local.
Abre tu terminal dentro del directorio `azerothcore-wotlk` y ejecuta:
```
git checkout master; git pull
```
### 3. Crear un nuevo branch
**IMPORTANTE:** nunca cometas cambios en tu branch `master` , esto hará ver tu fork muy desordenado.
Cuando estés creando un nuevo branch, git creará una copia de tu branch **actual**.
Siempre asegurate de que estas en `master` branch **antes** de crear un nuevo branch escribiendo:
```
git checkout master
```
Crea un nuevo branch dandole un nombre que sea diferente que ningun branch ya existente.
Puedes darle cualquier nombre que quieras (substituye "xxx" con lo que sea que estas corrigiendo):
```
git checkout -b fix-issue-xxxx
```
### 4. Añadir tus cambios de C++ (si hay alguno)
Si no has hecho ningún cambio al C++, puedes saltar este paso. De lo contrario ¡Abre tu editor y hazlos ahora! Te esperaré...
En esta guía vamos a asumir que has modificado el archivo `instance_deadmines.cpp`
Ahora añade tu archivo(s) para que sean cometidos:
```
git add src/server/scripts/EasternKingdoms/Deadmines/instance_deadmines.cpp
```
Si has modificado mas archivos, solo añadelos usando `git add path/to/file`
Puedes usar el comando `git status` para comprobar que archivos han sido seleccionados para ser cometidos:
### 5. Añade tus cambios SQL (si hay alguno)
Si no has hecho ningún cambio SQL, puedes saltar este paso. De lo contrario, ejecuta lo siguiente:
```
./data/sql/updates/pending_db_world/create_sql.sh
```
Esto generará un nuevo archivo ubicado en `data/sql/updates/pending_db_world`
teniendo un nombre único como `rev_XXXXXXXXXXXX.sql`
Abrelo con un editor de texto. Te darás cuenta de que contiene código SQL como:
```
INSERT INTO `version_db_world` (`sql_rev`) VALUES ('XXXXXXXXXXXX');
```
NO elimines esta linea. Añade tu código SQL debajo y guardalo.
Ahora añade este archivo para que sea cometido usando el comando `git add path/to/file`:
```
git add data/sql/updates/pending_db_world/rev_XXXXXXXXXXXX.sql
```
(obviamente remplaza `rev_XXXXXXXXXXXX.sql` con el verdadero nombre del archivo)
### 6. Commit & Push tus cambios
#### Hacer solo UNA vez: git config
Primero antes que todo asegurate de usar la plantilla de commit AC (esto debería ser necesario solo una vez):
```
git config --local commit.template ".git_commit_template.txt"
```
Cuando escribas tu mensage de commit, este usará el editor de texto por defecto `Vim` que es bastante complicado de manipular. Sin embargo puedes mantenerlo mas simple usando el editor `Nano` . Aquí está como proceder, escribe:
```
git config --global core.editor "nano"
```
#### Git commit
Luego comete tus cambios escribiendo:
```
git commit
```
Se te pedirá que especifique un mensaje de confirmación apropiado. Por favor, siga las pautas de formato aquí (= cada línea que empieza por un # que será ignorado en el mensaje de confirmación), y puede referirse a una confirmación como [esto](https://github.com/azerothcore/mod-npc-beastmaster/commit/53cf90233091db2191b522f0fa7c4b6009dca22e) como un ejemplo.
Si estas usando `Nano`, pressiona [ctrl]+[x] y escribe yes para guardar y salir (los otros comandos estan escritos abajo de la interfaz en `Nano`, y pueden ser encontrados facilmente en la net o escribiendo `man nano` en la terminal).
Verifica que estás satisfecho usando `git show`. Y sal usando [q]. Si no estas satisfecho, puedes hacer un recommit al **último commit local** escribiendo `git commit --amend`.
Ahora es el momento de hacer un push remotamente.
Si usas el comando `git push` por primera vez en este branch,
git te pedirá que especifiques a que branch remoto quieres hacer el push.
Así que deberías ejecutar:
```
git push --set-upstream origin fix-issue-xxxx
```
(Por supuesto remplaza `fix-issue-xxxx` con el nombre de tu branch)
### 7. Abrir la PR
Vuelve al [repositorio principal AzerothCore](https://github.com/azerothcore/azerothcore-wotlk),
te darás cuenta de que GitHub es lo suficientemente listo para darse cuenta de que est´´as a punto de abrir una PR
y muestra este recuadro amarillo claro:
Haz click en el botón verde de "Compare & pull request" (ubicado a la derecha).
Ahora llena la plantilla de la PR siguiendo las instrucciones que aparecerán en tu pantalla,
no te olvides de añadir **las instrucciones de testing** para que la gente pueda probar tu PR y pueda ser unida:
Tambien es una buena practica de comprobar la ventana de "File changes" para ver que todo está a tu gusto:
**NOTA:** No respondemos bien con los leechers! Si tu fix viene de otra organizacion o persona deberías SIEMPRE dar credito al autor original y el commit.
Eso es todo!
## FAQ
### Hay algo mal o faltan archivos en los cambios, Quiero subir más cambios
Solo edita/añade los archivos que quieras, `git add` , luego haz el commit y el push otra vez.
Si refrescas la pagna de tu PR verás los cambios.
### Ya he creado una PR, debería crear otra?
Solo repite el procedimiento empezando desde el paso 3.
Se cuidadoso creando un nuevo branch: **debes** estar en el `master` branch primero (escribe `git checkout master`).
### Como puedo actualizar el master branch de mi fork?
Si nunca has actualizado tu fork antes, escribe:
```
git remote add upstream https://github.com/azerothcore/azerothcore-wotlk.git
```
Luego sigue estos pasos:
1) `git checkout master`
2) `git fetch upstream`
3) `git merge upstream/master`
4) `git push origin master`
Y ya has actualizado tu fork :)
### Cómo puedo actualizar mi branch con el ultimo master?
Tienes que actualizar el master branch de tu fork primero (mirar arriba).
Luego solo `git checkout your-branch` y `git merge master`.
### Cuánto tiempo tardará que mi PR sea revisada, testeada y unida?
Esto es un proyecto de codigo abierto y la gente trabaja en su tiempo libre, así que no podemos estimarlo.
Lo que si podemos recomendar es: escribe instrucciones **claras** para testear tu PR, asi sera más fácil para todos de testearlo.
Si tus instrucciones no son claras o inexistentes,
solo los usuarios avanzados seran capaces de testear tu PR y tardara mucho más tiempo.
### Qué terminal fue usada en este tutorial?
https://github.com/robbyrussell/oh-my-zsh
Pero cualquier terminal de linux/mac esta bien también
Si tienes tan mala suerte de estar en Windows, usa [git bash](https://git-scm.com/downloads).
### Do I have to re-autenticar cada vez que uso git push?
Puedes clonar tu propio fork usando SSH en vez de HTTPS y luego sigue [esta guía](https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/adding-a-new-ssh-key-to-your-github-account) to set the SSH keys.
De esta manera puedes usar `git push` sin tener que repetir tu contraseña.
|
