# gt: General Translation CLI tool: Ramificación
URL: https://generaltranslation.com/es/docs/cli/branching.mdx
---
title: Ramificación
description: Sigue las traducciones por separado para distintas ramas de Git
---

## Resumen

La ramificación te permite llevar un seguimiento independiente de las traducciones para distintas ramas de Git en tu proyecto.
Esto es útil cuando trabajas en ramas de funcionalidad que introducen contenido nuevo o modifican texto existente, y quieres mantener esas traducciones aisladas de tu rama principal hasta que la funcionalidad se integre.

Cuando la ramificación está habilitada, la CLI detecta automáticamente tu rama actual de Git 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 la integres.

<Callout type="info">
  La ramificación es una función de GT Cloud y requiere un plan de pago. Si intentas crear una rama no predeterminada sin un plan de pago, la CLI volverá a usar la rama predeterminada.
</Callout>

***

## Uso

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

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

De forma predeterminada, la CLI detectará automáticamente tu 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

| Flag                         | 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` | Desactiva la detección automática de relaciones entre ramas. Usa solo la rama especificada manualmente.         |

***

## Cómo funciona

Cuando la ramificación está habilitada, la CLI hace lo siguiente:

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

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

3. **Rastrea las relaciones entre ramas**: Identifica las ramas que se han fusionado en la rama actual (ramas entrantes) y la rama a partir de la cual 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 rama nueva, 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

Al trabajar en una rama de funcionalidad, la CLI hace seguimiento de lo siguiente:

* **Ramas entrantes**: ramas que se han fusionado en tu rama actual. Esto permite incorporar las traducciones de las ramas fusionadas.
* **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 quedará asociada a tu rama de funcionalidad hasta que se fusione.

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

***

## Configuración

Puedes configurar las opciones de ramificación 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`            | Activa la ramificación en el proyecto                                                     | `false`        |
| `currentBranch`      | Anula el nombre de la rama actual (en lugar de detectarlo automáticamente)                | `undefined`    |
| `autoDetectBranches` | Detecta 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` anulará `branchOptions.enabled` y `--disable-branch-detection` anulará `branchOptions.autoDetectBranches`.
</Callout>

***


## Flujo de trabajo de ejemplo

Este es un flujo de trabajo típico con ramificación:

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. **Traduce con ramificación habilitada**:
   ```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 feature**: cualquier traducción adicional permanece en tu rama de funcionalidad.

5. **Fusiona tu rama de funcionalidad** en `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 rama

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

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


### Usar un remoto no estándar

Si tu remoto de Git no se llama `origin`, configura el nombre del remoto en tu 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 rastrear las ramas de origen o padre:

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