Personaliza la apariencia del modo vc en mode-line

Utilizo vc-modepara mostrar información sobre el estado actual de VC en mi línea de modo, así:

(setq mode-line-format '(… (vc-mode vc-mode) …))

Sin embargo, encuentro el formato predeterminado de vc-modebastante detallado. Notablemente, incluye el nombre del back-end VC actual, lo que no es particularmente interesante para mí: generalmente sé en qué VCS es el búfer actual y, de todos modos, realmente no uso ningún VCS que no sea Git.

¿Cómo puedo personalizar la apariencia de vc-mode? Idealmente, escondería el nombre del backend y mostraría solo el nombre de la rama actual (o probablemente algo similar a git describe).

Alternativamente, si vc-modeno se puede personalizar, ¿puedo obtener de alguna manera el nombre de la rama actual de VC, para usar en una (:eval …)construcción personalizada ?

¿Cómo puedo personalizar la apariencia de vc-mode? Idealmente, escondería el nombre del backend y mostraría solo el nombre de la rama actual.

Eso es más o menos lo que hace la línea de modo inteligente . Puede intentarlo, o simplemente puede copiar el consejo que utiliza:

(defadvice vc-mode-line (after strip-backend () activate)
  (when (stringp vc-mode)
    (let ((noback (replace-regexp-in-string 
                   (format "^ %s" (vc-backend buffer-file-name))
                   " " vc-mode)))
      (setq vc-mode noback))))

Tenga en cuenta que esta es una versión simplificada de la misma. Puede encontrar el código completo para el consejo aquí , que también aplica diferentes caras según el estado de la rama.

Como alternativa, aquí hay una versión aún más optimizada que no utiliza un consejo.

(setcdr (assq 'vc-mode mode-line-format)
        '((:eval (replace-regexp-in-string "^ Git" " " vc-mode))))

Tampoco estaba contento con el comportamiento predeterminado. Nunca podría mantener los caracteres de información vc en línea recta: ":" para editar, "@" para agregar, etc. Puede usar mi método con toda libertad.

Definí varias caras personalizadas para mostrar los estados en varios colores. Luego escribí una función para traducir la información de vc predeterminada en una cadena para insertar en la línea de modo. Luego agregué una :evallínea en mi definición de línea de modo para mostrarla.

;; Definir caras.

(defface mi / modo: vc-agregado
  `(
     (((color de clase))
        (: fondo "# FFAA55": primer plano "negro"))
     (t
        (: peso en negrita: subrayado t))
   )
  "Cara de etiqueta de estado de VC para archivos que se acaban de agregar a
control de versiones."
  : grupo 'MY / mode)

(defface my / mode: vc-edited
  `(
     (((color de clase))
        (: fondo "# F05B80": primer plano "negro")); ¿"# F04040" tal vez?
     (t
        (: peso en negrita: subrayado t))
   )
  "Etiqueta de estado de VC para archivos que están bajo control de versión
pero que han sido editados ".
  : grupo 'MY / mode)

(defface mi / modo: vc-in-sync
  `(
     (((color de clase))
        (: fondo "# 60CC60": primer plano "negro"))
     (t
        (: peso en negrita: subrayado t))
   )
  "Etiqueta de estado de VC para archivos que están bajo control de versión
y que están sincronizados con el repositorio ".
  : grupo 'MY / mode)

(defface mi / modo: vc-none
  `(
     (((color de clase))
        (: fondo "# 70A0D0": primer plano "negro"))
     (t
        (: peso en negrita: subrayado t))
   )
  "Cara de etiqueta de estado de VC para archivos que no están bajo versión
controlar"
  : grupo 'MY / mode)

(defface mi / modo: vc-unknown
  `(
     (((color de clase))
        (: fondo "# FF0000": primer plano "blanco"))
     (t
        (: peso en negrita: subrayado t))
   )
  "Cara de etiqueta de estado de VC para archivos cuyo estado de control de versiones
no puede ser determinado."
  : grupo 'MY / mode)

(defvar my-vc-mode-attrs
  '(("". ("NoVC" my / mode: vc-none))
    ("-". ("VC =" my / mode: vc-in-sync))
    (":". ("VC>" my / mode: vc-edited))
    ("@". ("VC +" mi / modo: vc-agregado))
    ("?". ("? VC?" Mi / modo: vc-desconocido))
    )
  "Tabla de búsqueda para traducir el carácter vc-mode a otra cadena / cara".
)


;; Esta función me ayuda a comprender el estado del control de versiones.
(defun my-mode-line-vc-info ()
  "Devuelve la información del estado del control de versiones sobre el archivo en
el búfer actual, como una cadena con fuente.

La variable de línea de modo `vc-mode 'es nula si el archivo no está bajo
control de versiones, y muestra un guión o dos puntos dependiendo de si
El archivo ha sido modificado desde el registro. Nunca puedo mantener esos
Derecho.

Esta función devuelve \ "NoVC \" si el archivo no está bajo la versión 
controlar. Muestra una cadena con un signo = si el archivo está sincronizado
con su control de versión y una cadena con un signo> si el archivo tiene
modificado desde su último registro ".
  (let * ((clase
          (cond
           ;; Si no está bajo control de versiones
           ((no modo vc)
            "")

           ;; Si está bajo control de versión, decodifique el carácter -: @
           ((string-match "\\`? \\ (?: CVS \\ | Git \\) \\ ([-: @] \\) \\ ([^^: ~ \ x00- \ x1F \\\ \ /] + \\)? "modo vc)
            (match-string-no-properties 1 vc-mode))

           ;; De lo contrario, indique confusión
           (t
            "?")
           ))

         (rama
          (if (cualquier clase '("-" ":" "@"))
              (concat "" (match-string-no-properties 2 vc-mode))
            ""))

         ;; Obtener la lista de propiedades para el carácter de clase anterior
         (accesorios (cdr (clase assoc my-vc-mode-attrs)))
         )

    (concat (propiedad (car props) 'cara (cadr props))
            rama)))

(set-default 'mode-line-format
   '(
     ...
        (: eval (my-mode-line-vc-info))
     ...))