# gt: General Translation CLI tool: uso de ramas
URL: https://generaltranslation.com/es/docs/cli/branching.mdx
---
title: uso de ramas
description: Haz un seguimiento separado de las traducciones para distintas ramas de Git
---

## Resumen

Branching te permite hacer un seguimiento por separado de las traducciones para diferentes ramas de git en tu proyecto.
Esto resulta útil cuando trabajas en ramas de funcionalidad que introducen contenido nuevo o modifican texto existente, y quieres mantener esas traducciones aisladas de tu rama main hasta que combines la rama.

Cuando el uso de ramas está habilitado, la CLI detecta automáticamente tu rama de git actual y asocia las traducciones con esa rama.
Las traducciones creadas en una rama de funcionalidad no afectarán a tus traducciones de producción hasta que combines la rama.

<Callout type="info">
  Branching es una funcionalidad de GT Cloud y requiere un plan de pago. Si intentas crear una rama no predeterminada sin un plan de pago, la CLI usará la rama predeterminada.
</Callout>

***

## Uso

Para habilitar el uso de ramas, usa la opción `--enable-branching` con el comando `translate`:

```bash
npx gt translate --enable-branching
```

Por defecto, la CLI detectará automáticamente la rama actual de Git. Si en su lugar quieres especificar un nombre de rama personalizado:

```bash
npx gt translate --enable-branching --branch my-feature-branch
```

***


## Opciones

| Opción                       | Descripción                                                                                                     |
| ---------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `--enable-branching`         | Habilita el uso de ramas en el proyecto. Es necesario para usar el seguimiento de traducciones basado en ramas. |
| `--branch <branch>`          | Especifica un nombre de rama personalizado en lugar de detectarlo automáticamente desde Git.                    |
| `--disable-branch-detection` | Deshabilita la detección automática de relaciones entre ramas. Usa solo la rama especificada manualmente.       |

***

## Cómo funciona

Cuando el uso de ramas está habilitado, la CLI hace lo siguiente:

1. **Detecta la rama actual**: Usa git para determinar en qué rama te encuentras.

2. **Identifica la rama predeterminada**: Determina cuál es la rama predeterminada (normalmente `main` o `master`) comprobando la referencia HEAD remota.

3. **Hace un seguimiento de las relaciones entre ramas**: Identifica las ramas que se han combinado en la rama actual (ramas entrantes) y la rama desde la que se creó la rama actual (rama padre).

4. **Asocia las traducciones con las ramas**: Todas las traducciones se etiquetan con la rama actual, lo que las mantiene separadas de las de otras ramas.

5. **Hereda traducciones de las ramas padre**: Cuando creas una nueva rama, las traducciones se heredan automáticamente de la rama padre, para que no se vuelvan a traducir ni se te cobre dos veces.

### Herencia de traducciones

Cuando trabajas en una rama de funcionalidad, la CLI lleva un seguimiento de lo siguiente:

* **Ramas entrantes**: ramas que se han combinado con tu rama actual. Esto permite incorporar las traducciones de las ramas combinadas.
* **Rama de origen**: la rama a partir de la cual se creó tu rama actual (normalmente, la rama predeterminada). Esto permite que tu rama de funcionalidad herede las traducciones existentes.

Esto significa que, cuando creas una nueva rama de funcionalidad a partir de `main`, tu rama tendrá acceso a todas las traducciones existentes de `main`. Cualquier traducción nueva que crees se asociará con tu rama de funcionalidad hasta que se combine.

Después de combinar la rama de funcionalidad de nuevo con `main`, las traducciones de la rama de funcionalidad se incorporan automáticamente a `main`.

***

## Configuración

Puedes configurar las opciones de uso de ramas en tu archivo `gt.config.json`:

```json title="gt.config.json"
{
  "branchOptions": {
    "enabled": true,
    "currentBranch": "my-feature-branch",
    "autoDetectBranches": true,
    "remoteName": "origin"
  }
}
```

| Propiedad            | Descripción                                                                       | Predeterminado |
| -------------------- | --------------------------------------------------------------------------------- | -------------- |
| `enabled`            | Habilitar uso de ramas para el proyecto                                           | `false`        |
| `currentBranch`      | Sobrescribir el nombre de la rama actual (en lugar de detectarlo automáticamente) | `undefined`    |
| `autoDetectBranches` | Detectar automáticamente las relaciones entre ramas (ramas entrantes y ramas de origen)       | `true`         |
| `remoteName`         | El nombre del remoto de git usado para detectar ramas                             | `"origin"`     |

<Callout type="info">
  Las opciones de la CLI tienen prioridad sobre las opciones del archivo de configuración. Por ejemplo, `--enable-branching` sobrescribirá `branchOptions.enabled` y `--disable-branch-detection` sobrescribirá `branchOptions.autoDetectBranches`.
</Callout>

***


## Flujo de trabajo de ejemplo

Aquí tienes un flujo de trabajo típico con uso de ramas:

1. **Crea una rama de funcionalidad**:
   ```bash
   git checkout -b feature/new-landing-page
   ```

2. **Añade nuevo contenido traducible** a tu rama de funcionalidad.

3. **Ejecuta la traducción con el uso de ramas habilitado**:
   ```bash
   npx gt translate --enable-branching
   ```
   La CLI detecta que estás en `feature/new-landing-page` y asocia todas las traducciones nuevas con esa rama.

4. **Sigue iterando en tu funcionalidad** - cualquier traducción adicional permanecerá en tu rama de funcionalidad.

5. **Combina tu rama de funcionalidad** con `main`:
   ```bash
   git checkout main
   git merge feature/new-landing-page
   ```

6. **Ejecuta translate en main**:
   ```bash
   npx gt translate --enable-branching
   ```
   La CLI detecta las traducciones de `feature/new-landing-page` e incorpora esas traducciones a `main`.

***

## Solución de problemas

### No se detectó la Branch

Si la CLI no puede detectar tu rama actual, puedes especificarla manualmente:

```bash
npx gt translate --enable-branching --branch my-branch
```


### Uso de un remoto no estándar

Si tu remoto de Git no se llama `origin`, configura el nombre del remoto en la configuración:

```json title="gt.config.json"
{
  "branchOptions": {
    "remoteName": "upstream"
  }
}
```

o usa la opción `--remote-name`:

```bash
npx gt translate --enable-branching --remote-name upstream
```


### Desactivar la detección de relaciones entre ramas

Si solo quieres usar la rama actual sin hacer seguimiento de las ramas entrantes o padre:

```bash
npx gt translate --enable-branching --branch my-branch --disable-branch-detection
```