Flycheck con file eseguibile relativo eslint

Molti progetti su cui lavoro install eslint come dipendenza dev, con un set personalizzato di plugin eslint. In questo momento, flycheck utilizza la versione di eslint installata a livello globale anziché la versione di eslint installata con ciascun progetto.

Vorrei invece puntare il flycheck su node_modules / eslint / bin / eslint.js. Il percorso completo dovrebbe dipendere dal percorso del file del buffer corrente in modo che io possa lavorare su più progetti contemporaneamente con ogni buffer usando un eseguibile eslint potenzialmente diverso.

È possibile? Qualche suggerimento su come farei per fare questo?

È possibile modificare a livello di programmazione flycheck-javascript-eslint-executable, ad es

(defun my/use-eslint-from-node-modules ()
  (let* ((root (locate-dominating-file
                (or (buffer-file-name) default-directory)
                "node_modules"))
         (eslint
          (and root
               (expand-file-name "node_modules/.bin/eslint"
                                 root))))
    (when (and eslint (file-executable-p eslint))
      (setq-local flycheck-javascript-eslint-executable eslint))))

(add-hook 'flycheck-mode-hook #'my/use-eslint-from-node-modules)

Questo codice cerca una node_modulesdirectory in qualsiasi genitore della directory del buffer e configura Flycheck per utilizzare un eseguibile eslint da quella directory se esiste.

Non ho abbastanza reputazione per commentare la soluzione accettata. Ma ne ho fatto una variante, che funziona bene con i pacchetti nidificati (ad esempio usando lerna ). Questo è esattamente lo stesso codice, tuttavia cerca node_modulesricorsivamente la cartella principale finché non trova un file eslintbinario e lo utilizza. In questo modo, puoi avere un progetto lerna con una sola configurazione eslint, condivisa tra tutti i sotto-pacchetti.

(defun my/use-eslint-from-node-modules ()
  (let ((root (locate-dominating-file
               (or (buffer-file-name) default-directory)
               (lambda (dir)
                 (let ((eslint (expand-file-name "node_modules/eslint/bin/eslint.js" dir)))
                  (and eslint (file-executable-p eslint)))))))
    (when root
      (let ((eslint (expand-file-name "node_modules/eslint/bin/eslint.js" root)))
        (setq-local flycheck-javascript-eslint-executable eslint)))))
(add-hook 'flycheck-mode-hook #'my/use-eslint-from-node-modules)

Sono su Windows e questo non funzionava per me, penso che il file eseguibile-p o forse gli interni flycheck non riuscissero a trovare il file corretto. Come quando funziona, punta al .cmdfile e non al .jsfile.

Ho trovato un commento in flycheck-eslint non usa la versione di eslint installata nel progetto JavaScript e il loro post sul blog per usare invece le variabili di directory .

Nella directory principale del progetto creare un file .dir-locals.el

((nil . ((eval . (progn
                   (add-to-list 'exec-path (concat (locate-dominating-file default-directory ".dir-locals.el") "node_modules/.bin/")))))))

Ora quando visito il file javascript flycheck-verify-setuptrova correttamente il file<dir>/node_modules/.bin/eslint.cmd

La mia soluzione precedente era una seccatura per lavorare su diversi progetti.

Ho modificato la risposta accettata alle stupidaggini di Windows con codice fisso.

(defun my/use-eslint-from-node-modules ()
  (let* ((root (locate-dominating-file
                (or (buffer-file-name) default-directory)
                "node_modules"))
         (eslint (and root
                      (expand-file-name "node_modules/.bin/eslint.cmd"
                                        root))))
    (when (and eslint (file-exists-p eslint))
      (setq-local flycheck-javascript-eslint-executable eslint))))

Ecco una soluzione che combina le risposte di Bae e lunaryorn usando un dir-locals.elfile nella directory principale del progetto (o, più specificamente, nella directory che contiene la node_modules/cartella in cui eslintrisiede il binario). Crea detto dir-locals.elfile con il seguente contenuto.

((js2-mode
   (flycheck-checker . javascript-eslint)
   (eval . (setq-local flycheck-javascript-eslint-executable
             (concat (locate-dominating-file default-directory
                       ".dir-locals.el") "node_modules/.bin/eslint")))))

Qui presumo che tu stia utilizzando la js2-modemodalità principale di emacs per modificare i file javascript. In caso contrario, cambia quella riga di conseguenza. La seconda riga del file rende il javascript-eslintcontrollo della sintassi l'unico da utilizzare all'interno di questo progetto. La terza riga imposta la variabile flycheck-javascript-eslint-executablesu <root-dir>/node_modules/.bin/eslint. In questo modo non modifichiamo emacs ' exec-path.

Ho provato alcune varianti di questo e non ho mai trovato esattamente quello che volevo. Ho finalmente livellato abbastanza in Emacs LISP per modificarlo a mio piacimento. Quello che fa la mia versione è cercare un eslint locale e se uno non viene trovato, ricade in uno installato globalmente:

(defun configure-web-mode-flycheck-checkers ()
    ;; See if there is a node_modules directory
    (let* ((root (locate-dominating-file
                  (or (buffer-file-name) default-directory)
                  "node_modules"))
           (eslint (or (and root
                            ;; Try the locally installed eslint
                            (expand-file-name "node_modules/eslint/bin/eslint.js" root))

                       ;; Try the global installed eslint
                       (concat (string-trim (shell-command-to-string "npm config get prefix")) "/bin/eslint"))))

      (when (and eslint (file-executable-p eslint))
        (setq-local flycheck-javascript-eslint-executable eslint)))

    (if eslint
        (flycheck-select-checker 'javascript-eslint)))