Source code management/es: Difference between revisions

Revision as of 18:58, 15 December 2018

Other languages:

Our main source code management tool is git. This article explains how to use it and how some general rules apply in the case of FreeCAD. You are highly advised to learn how git works first (there are a lot of tutorials and docs available for git on the internet) before working with the FreeCAD source code.

There are also many good graphical clients to git, such as git-cola, that make the whole process of managing git repositories easier. FYI there also exists a cursory intro to Developing FreeCAD with GitKraken.

Source Code Access

Everybody can access and get a copy of the FreeCAD source code, but only the FreeCAD project managers have write access to it. You can get a copy of the code, study it and modify it as you wish, but if you make a change that you wish to see included in the official source code, you need to ask for a pull request on the pull requests section of the FreeCAD forum.

NOTE

In all examples below, "GITHUB_USERNAME" represents your GitHub user account.

Official GitHub Repo

An easy way to start with the FreeCAD source code is using the official FreeCAD repository at https://github.com/FreeCAD/FreeCAD

Configurando tu nombre de usuario en Git

Los usuarios deberían enviar a sus repositorios de proyecto utilizando sus nombres de usuario de SourceForge.net. Si no está definido globalmente, lo puedes definir localmente para el repositorio de Gir actual así:

git config user.name "YOUR NAME"
git config user.email "GITHUB_USERNAME@users.noreply.github.com"

Ahora puedes utilizar alguna combinación de los comandos "git add" y "git commit" para crear uno o más envíos en tu repositorio local.

A note about Remotes

Please read some background to help you understand better the difference between what origin and upstream mean in the context of git. This section explains how to set the correct upstream and origin remote git repos. Essentially:

origin = Your fork of the FreeCAD git repo AKA https://github.com/GITHUB_USERNAME/FreeCAD.git
upstream = The official FreeCAD git repo AKA https://github.com/FreeCAD/FreeCAD.git
This is important to understand because if you git clone directly from upstream then confusingly, your origin will be listed as https://github.com/FreeCAD/FreeCAD.git
BTW, if you do this accidentally you can use the git remote rename command to remedy the situation.

So, based on the above, there are 2 main ways to setup your git environment:

We recommend the 1st method for the reason mentioned above.

1st Method: Fork on GitHub and clone your fork locally

Important Note

You will need to re-configure 'remote upstream' as mentioned above in "A note about Remotes"

This method is the recommended way since it takes less steps. You will essentially fork the FreeCAD repo on your own GitHub account and then clone said GitHub fork locally. Then you will set your upstream repo in git. The procedure is as follows:

Sign up for a GitHub account if you don't already have one
Go to the FreeCAD repo: https://github.com/FreeCAD/FreeCAD
In the top right of the page find and press the "Fork" button (this will essentially git clone the official FreeCAD repo to your personal GitHub repo: https://github.com/GITHUB_USERNAME/FreeCAD.git)
On your machine, clone your newly created FreeCAD fork by opening a terminal and typing:
```
git clone https://github.com/GITHUB_USERNAME/FreeCAD.git
```
Once the clone process is complete, now set your upstream remote repo (see "A note about Remotes"). Find out what and where your remote git repositories are set to. Type git remote -v and the output should look similar to:
```
 [foo@bar FreeCAD]$ git remote -v
     origin	https://github.com/GITHUB_USERNAME/FreeCAD.git (fetch)
     origin	https://github.com/GITHUB_USERNAME/FreeCAD.git (push)
```

Great. Now set your upstream repo

[foo@bar FreeCAD]$ git remote add upstream https://github.com/FreeCAD/FreeCAD.git

Check your remotes again, they should look similiar to this:

 [foo@bar FreeCAD]$ git remote -v
    origin	https://github.com/GITHUB_USERNAME/FreeCAD.git (fetch)
    origin	https://github.com/GITHUB_USERNAME/FreeCAD.git (push)
    upstream	https://github.com/FreeCAD/FreeCAD.git (fetch)
    upstream	https://github.com/FreeCAD/FreeCAD.git (push)

Now we can start developing. Please refer to "Git Development Process"

2nd Method: Clone Official FreeCAD git repo to your local machine

Important Note

You will need to re-configure both 'remote origin' and 'remote upstream' please refer to above "A note about Remotes"

This method of setuping your git environment takes a few more steps then the 1st method. You will clone the FC git repo directly to your local machine and then alter your remotes via the terminal. The procedure is as follows:

Clone the FreeCAD code with git:

git clone https://github.com/FreeCAD/FreeCAD.git

Create an account on a public git server (GitHub, GitLab, etc... for our purposes we're assuming it's GitHub)
Find out what and where your remote git repositories are set to:
```
git remote -v
```

This will return something that looks like the following:

[foo@bar FreeCAD]$ git remote -v
    origin https://github.com/FreeCAD/FreeCAD.git (fetch)
    origin https://github.com/FreeCAD/FreeCAD.git (push)

As was explained above in "A note about Remotes" you need to modify these remote git repo addresses.
So first set up your origin remote:
```
[foo@bar FreeCAD]$ git remote add origin https://github.com/GITHUB_USERNAME/FreeCAD.git
```

Then we set up our upstream remote:

[foo@bar FreeCAD]$ git remote add upstream https://github.com/FreeCAD/FreeCAD.git

Check your remotes again, they should look similiar to this:

 [foo@bar FreeCAD]$ git remote -v
    origin	https://github.com/GITHUB_USERNAME/FreeCAD.git (fetch)
    origin	https://github.com/GITHUB_USERNAME/FreeCAD.git (push)
    upstream	https://github.com/FreeCAD/FreeCAD.git (fetch)
    upstream	https://github.com/FreeCAD/FreeCAD.git (push)

Now we can start developing. Please refer to "Git Development Process"

En desarrollo

Antes de nada nunca desarrolles en el ramal principal! Crea un ramal local para el desarrollo. Puedes aprender a hacer esto aquí.

Ramificado

Una importante característica de Git es que es extremadamente sencillo trabajar con ramas y fusionarlas. La mejor forma de trabajar recomienda crear una nueva rama siempre que quieras trabajar en una nueva característica. La creación de una rama se hace con:

git branch myNewBranch
git checkout myNewBranch

o, ambas operaciones en una:

git checkout -b myNewBranch

siempre puedes comprobar con que rama estas:

git branch

Envío

Una vez que hagas algo de trabajo, envíalo con:

git commit -a

A diferencia de SVN, tienes que especificar los archivos que quieres enviar (o todos con la opción -a). Tu editor de texto se abrirá para permitirte escribir un mensaje de envío.

Publicación de tu trabajo en el repositorio de sourceforge

Después de hacer algunos cambios en tu ramal local y enviarlos (es decir, enviarlos "localmente") puedes enviar tu repositorio al servidor. Esto abre tu ramal al público y permite que los desarrolladores principales revisen e integren tu ramal en el principal.

git push <REMOTENAME> <BRANCHNAME> 
git push origin my-branch

For further info on this subject please read https://help.github.com/articles/pushing-to-a-remote/

Escribiendo buenos mensajes de envío

Deberías tratar de trabajar en pedazos pequeños. Si no puedes resumir tus cambios en una frase, entonces posiblemente ha pasado pasado demasiado tiempo desde que hiciste un envío. También es importante que ofrezcas descripciones de tu trabajo que sean útiles y ayuden. Para los mensajes de envío, FreeCAD ha adoptado un formato mencionado en el libro Pro Git (mira #Otras lecturas).

 Resumen corto (50 caracteres o menos) de cambios

Texto de explicación más detallado, si es necesario. En unos 72 caracteres.
En algunos contextos, la primera línea es tratada como el tema
de un email y el resto del texto como el cuerpo. La línea en blanco
separando el tema del cuerpo es crítica (a menos que omitas el cuerpo por
completo); las herramientas de recálculo se pueden confundir si pones los
dos juntos.

Más párrafos van después de líneas en blanco. 

 - Las listas con viñetas también están bien

 - Tipicamente un guión o asterisco se utiliza para la viñeta, precedido 
   por un espacio en blanco, con líneas en blanco en medio, pero las 
   convenciones aquí varían

Si estas haciendo un montón de trabajo relacionado, se sugiere aquí que deberías hacer tantos envíos grandes o pequeños como sea necesario para que tengan sentido en lo que estés trabajando utilizado los mensajes cortos de envío. Cuando quieras fusionarlos, haz un registro master..BRANCH y utiliza el resultado para tu mensaje de envío. Cuando fusionas con el principal utiliza la opción --squash y envía con tu mensaje de envío. Esto te permitirá ser muy liberal con tus envíos y ayudar a proporcionar un buen nivel de detalle en los mensajes de envío sin demasiadas descripciones distintas.

Advanced git operations

Resolving Merge Conflicts

git-scm explanation on how conflicts are presented
GitHub article on resolving merge conflicts via the command-line
Customize your preferred merge tool when you encounter a git conflict.

Applying patches via git

Git has the capability to merge patches/diffs. To read more about this read the following reference: https://www.drupal.org/node/1399218

git apply [patch-name].patch

Apply a patch via curl

A very handy and powerful feature of git and the command line is the ability to quickly test patches all through the terminal.

curl -O https://github.com/FreeCAD/FreeCAD/commit/[patch-name].patch
git apply [patch-name].patch

or alternatively, using bash pipes you can make a sweet 1-liner:

curl https://github.com/FreeCAD/FreeCAD/commit/c476589652a0f67b544735740e20ff702e8d0621.patch | git apply -

Useful tip: Just add .diff or .patch at the end of the URL for a GitHub commit page, Pull Request, or Compare View and it'll show you theplaintext view of that page. Example:

Regular GitHub page: https://github.com/FreeCAD/FreeCAD/commit/c476589652a0f67b544735740e20ff702e8d0621

'Diffed' GitHub page: https://github.com/FreeCAD/FreeCAD/commit/c476589652a0f67b544735740e20ff702e8d0621.diff

'Patched' GitHub page: https://github.com/FreeCAD/FreeCAD/commit/c476589652a0f67b544735740e20ff702e8d0621.patch

Creating patches from git

There are times when one may need to create a patch instead of submitting a PR. The following workflow explains how to do this:

Make sure you are in the correct branch (i.e. not the master branch) by checking with
```
git branch -v
```
Create the patch: we do this by using the git format-patch command which we patch against the master branch and redirect to STDOUT. We create the patch in the directory outside of the source build (in order not to pollute the source dir itself, this is optional as you can decide the location wherever you want the patch to be created)
```
git format-patch master --stdout > ../patch.name.patch
```
Another method is to use git format-patch HEAD^ or git format-patch HEAD~1 The ^ or 1 can be changed to number of commits that should be covered i.e.: ^^^ or ~3.
```
git format-patch HEAD^
```

Reversing a patch in git

If you've followed the instructions above and then have a change of heart about using the patch, you can quickly reverse it using:

git apply -R path/file.patch

or another way is to use:

git checkout -f

which will remove non-committed changes to the branch

Stashing git commits

Say you're working on a branch and you find yourself making some modification to the source that is out of the scope of your current branch in other words it would be better to add certain commits to a whole other branch and submit it instead of the current one. This is where the git stash command can be very useful. The git stash command can help you to (temporarily but safely) store your uncommitted local changes.

git stash

Then in the future when you want to use these commits you can

git stash apply

or

git stash pop

pop will delete the stash If you have multiple stashes you can

git stash list

To read more about what other functions you can use checkout https://medium.freecodecamp.org/useful-tricks-you-might-not-know-about-git-stash-e8a9490f0a1a

What is the latest FreeCAD Dev Revision

There are 2 ways to do this:

1st method: In your cloned git directory type:

git rev-list --count master

2nd method: Browse https://github.com/FreeCAD/FreeCAD and read the amount of commits FreeCAD is at.

What is the Revision number of a specific commit hash and visa ver?

git rev-list --count 9948ee4
13541

some forum topics in this regard:

How is the Revision number in FreeCAD help about generated?

https://forum.freecadweb.org/viewtopic.php?f=4&t=3025

Alternative repositories

The beauty of git is that everybody can clone a project, and start modifying the code. Several frequent collaborators of the FreeCAD project have their own git repository, where they build up their work before it is ready to be included in the official source code, or simply where they experiment new ideas. In certain cases, you might want to clone your FreeCAD code from one of these, instead of the official repos, to benefit from the changes their users did.

Be warned, though, that this is at your own risk, and only the official repository above is fully guaranteed to work and contain clean code.

It is also possible to attach several remote repositories to a same local FreeCAD git code, using the "git remote" command. This is useful to keep in sync with the master code branch, but keep an eye on the work of different developers.

Using git in a Graphical User Interface

Developing FreeCAD with GitKraken

Otras lecturas

@@ Line 174: / Line 174: @@
   <li>Create the patch: we do this by using the '''git format-patch''' command which we patch against the master branch and redirect to STDOUT. We create the patch in the directory outside of the source build (in order not to pollute the source dir itself, this is optional as you can decide the location wherever you want the patch to be created)
   <pre>git format-patch master --stdout > ../patch.name.patch</pre></li>
+  <li>Another method is to use '''git format-patch HEAD^''' or '''git format-patch HEAD~1''' The ^ or 1 can be changed to number of commits that should be covered i.e.: ^^^ or ~3.
+  <pre>git format-patch HEAD^</pre></li> It will create a patch or series of patches with file name format XXXX-commit-message.patch. An example: 0001-fix-ViewProjMatrix-getProjectionMatrix.patch
 </ol>
@@ Line 203: / Line 206: @@
 == What is the Revision number of a specific commit hash and visa ver? ==
+ git rev-list --count 9948ee4
 * some forum topics in this regard:
 ** https://forum.freecadweb.org/viewtopic.php?f=10&t=26673
@@ Line 208: / Line 214: @@
 ** https://forum.freecadweb.org/viewtopic.php?f=18&t=12883&p=103207#p103203
 ** https://forum.freecadweb.org/viewtopic.php?f=10&t=31118
 == How is the Revision number in FreeCAD help about generated? ==