811 lines
34 KiB
EmacsLisp
811 lines
34 KiB
EmacsLisp
;;; editorconfig.el --- EditorConfig Plugin -*- lexical-binding: t -*-
|
|
|
|
;; Copyright (C) 2011-2024 Free Software Foundation, Inc.
|
|
|
|
;; Author: EditorConfig Team <editorconfig@googlegroups.com>
|
|
;; Version: 0.11.0
|
|
;; URL: https://github.com/editorconfig/editorconfig-emacs#readme
|
|
;; Package-Requires: ((emacs "26.1"))
|
|
;; Keywords: convenience editorconfig
|
|
|
|
;; See
|
|
;; https://github.com/editorconfig/editorconfig-emacs/graphs/contributors or
|
|
;; https://github.com/editorconfig/editorconfig-emacs/blob/master/CONTRIBUTORS
|
|
;; for the list of contributors.
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
;; GNU Emacs is free software: you can redistribute it and/or modify
|
|
;; it under the terms of the GNU General Public License as published by
|
|
;; the Free Software Foundation, either version 3 of the License, or
|
|
;; (at your option) any later version.
|
|
|
|
;; GNU Emacs is distributed in the hope that it will be useful,
|
|
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
;; See the GNU General Public License for more details.
|
|
|
|
;; You should have received a copy of the GNU General Public License
|
|
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
;;; Commentary:
|
|
|
|
;; EditorConfig helps developers define and maintain consistent
|
|
;; coding styles between different editors and IDEs.
|
|
|
|
;; The EditorConfig project consists of a file format for defining
|
|
;; coding styles and a collection of text editor plugins that enable
|
|
;; editors to read the file format and adhere to defined styles.
|
|
;; EditorConfig files are easily readable and they work nicely with
|
|
;; version control systems.
|
|
|
|
;;; News:
|
|
|
|
;; - In `editorconfig-indentation-alist', if a mode is associated to a function
|
|
;; that function should not set the vars but should instead *return* them.
|
|
;; - New var `editorconfig-indent-size-vars' for major modes to set.
|
|
;; - New hook `editorconfig-get-local-variables-functions' to support
|
|
;; additional settings.
|
|
|
|
;;; Code:
|
|
|
|
(require 'cl-lib)
|
|
|
|
(eval-when-compile (require 'subr-x))
|
|
|
|
(require 'editorconfig-core)
|
|
|
|
(defgroup editorconfig nil
|
|
"EditorConfig Emacs Plugin.
|
|
|
|
EditorConfig helps developers define and maintain consistent
|
|
coding styles between different editors and IDEs."
|
|
:tag "EditorConfig"
|
|
:prefix "editorconfig-"
|
|
:group 'tools)
|
|
|
|
(when (< emacs-major-version 30)
|
|
(define-obsolete-variable-alias
|
|
'edconf-custom-hooks
|
|
'editorconfig-after-apply-functions
|
|
"0.5")
|
|
(define-obsolete-variable-alias
|
|
'editorconfig-custom-hooks
|
|
'editorconfig-after-apply-functions
|
|
"0.7.14")
|
|
(defcustom editorconfig-after-apply-functions ()
|
|
"A list of functions after loading common EditorConfig settings.
|
|
|
|
Each element in this list is a hook function. This hook function
|
|
takes one parameter, which is a property hash table. The value
|
|
of properties can be obtained through gethash function.
|
|
|
|
The hook does not have to be coding style related; you can add
|
|
whatever functionality you want. For example, the following is
|
|
an example to add a new property emacs_linum to decide whether to
|
|
show line numbers on the left:
|
|
|
|
(add-hook \\='editorconfig-after-apply-functions
|
|
\\='(lambda (props)
|
|
(let ((show-line-num (gethash \\='emacs_linum props)))
|
|
(cond ((equal show-line-num \"true\") (linum-mode 1))
|
|
((equal show-line-num \"false\") (linum-mode 0))))))
|
|
|
|
This hook will be run even when there are no matching sections in
|
|
\".editorconfig\", or no \".editorconfig\" file was found at all."
|
|
:type 'hook))
|
|
|
|
(when (< emacs-major-version 30)
|
|
(defcustom editorconfig-hack-properties-functions ()
|
|
"A list of function to alter property values before applying them.
|
|
|
|
These functions will be run after loading \".editorconfig\" files and before
|
|
applying them to current buffer, so that you can alter some properties from
|
|
\".editorconfig\" before they take effect.
|
|
\(Since 2021/08/30 (v0.9.0): Buffer coding-systems are set before running
|
|
this functions, so this variable cannot be used to change coding-systems.)
|
|
|
|
For example, Makefiles always use tab characters for indentation: you can
|
|
overwrite \"indent_style\" property when current `major-mode' is a
|
|
`makefile-mode' with following code:
|
|
|
|
(add-hook \\='editorconfig-hack-properties-functions
|
|
\\='(lambda (props)
|
|
(when (derived-mode-p \\='makefile-mode)
|
|
(puthash \\='indent_style \"tab\" props))))
|
|
|
|
This hook will be run even when there are no matching sections in
|
|
\".editorconfig\", or no \".editorconfig\" file was found at all."
|
|
:type 'hook))
|
|
(make-obsolete-variable 'editorconfig-hack-properties-functions
|
|
'editorconfig-get-local-variables-functions
|
|
"2024")
|
|
|
|
(define-obsolete-variable-alias
|
|
'edconf-indentation-alist
|
|
'editorconfig-indentation-alist
|
|
"0.5")
|
|
(defcustom editorconfig-indentation-alist
|
|
;; For contributors: Sort modes in alphabetical order
|
|
'((apache-mode apache-indent-level)
|
|
(awk-mode c-basic-offset)
|
|
(bash-ts-mode sh-basic-offset)
|
|
(bpftrace-mode c-basic-offset)
|
|
(c++-mode c-basic-offset)
|
|
(c++-ts-mode c-basic-offset
|
|
c-ts-mode-indent-offset)
|
|
(c-mode c-basic-offset)
|
|
(c-ts-mode c-basic-offset
|
|
c-ts-mode-indent-offset)
|
|
(cmake-mode cmake-tab-width)
|
|
(cmake-ts-mode cmake-tab-width
|
|
cmake-ts-mode-indent-offset)
|
|
(coffee-mode coffee-tab-width)
|
|
(cperl-mode cperl-indent-level)
|
|
(crystal-mode crystal-indent-level)
|
|
(csharp-mode c-basic-offset)
|
|
(csharp-ts-mode c-basic-offset
|
|
csharp-ts-mode-indent-offset)
|
|
(css-mode css-indent-offset)
|
|
(css-ts-mode css-indent-offset)
|
|
(d-mode c-basic-offset)
|
|
(elixir-ts-mode elixir-ts-indent-offset)
|
|
(emacs-lisp-mode . editorconfig--get-indentation-lisp-mode)
|
|
(enh-ruby-mode enh-ruby-indent-level)
|
|
(erlang-mode erlang-indent-level)
|
|
(ess-mode ess-indent-offset)
|
|
(f90-mode f90-associate-indent
|
|
f90-continuation-indent
|
|
f90-critical-indent
|
|
f90-do-indent
|
|
f90-if-indent
|
|
f90-program-indent
|
|
f90-type-indent)
|
|
(feature-mode feature-indent-offset
|
|
feature-indent-level)
|
|
(fsharp-mode fsharp-continuation-offset
|
|
fsharp-indent-level
|
|
fsharp-indent-offset)
|
|
(gdscript-mode gdscript-indent-offset)
|
|
(go-ts-mode go-ts-mode-indent-offset)
|
|
(graphql-mode graphql-indent-level)
|
|
(groovy-mode groovy-indent-offset)
|
|
(haskell-mode haskell-indent-spaces
|
|
haskell-indent-offset
|
|
haskell-indentation-layout-offset
|
|
haskell-indentation-left-offset
|
|
haskell-indentation-starter-offset
|
|
haskell-indentation-where-post-offset
|
|
haskell-indentation-where-pre-offset
|
|
shm-indent-spaces)
|
|
(haxor-mode haxor-tab-width)
|
|
(hcl-mode hcl-indent-level)
|
|
(html-ts-mode html-ts-mode-indent-offset)
|
|
(idl-mode c-basic-offset)
|
|
(jade-mode jade-tab-width)
|
|
(java-mode c-basic-offset)
|
|
(java-ts-mode c-basic-offset
|
|
java-ts-mode-indent-offset)
|
|
(js-mode js-indent-level)
|
|
(js-ts-mode js-indent-level)
|
|
(js-jsx-mode js-indent-level sgml-basic-offset)
|
|
(js2-mode js2-basic-offset)
|
|
(js2-jsx-mode js2-basic-offset sgml-basic-offset)
|
|
(js3-mode js3-indent-level)
|
|
(json-mode js-indent-level)
|
|
(json-ts-mode json-ts-mode-indent-offset)
|
|
(jsonian-mode jsonian-default-indentation)
|
|
(julia-mode julia-indent-offset)
|
|
(kotlin-mode kotlin-tab-width)
|
|
(kotlin-ts-mode kotlin-ts-mode-indent-offset)
|
|
(latex-mode . editorconfig--get-indentation-latex-mode)
|
|
(lisp-mode . editorconfig--get-indentation-lisp-mode)
|
|
(livescript-mode livescript-tab-width)
|
|
(lua-mode lua-indent-level)
|
|
(lua-ts-mode lua-ts-indent-offset)
|
|
(magik-mode magik-indent-level)
|
|
(magik-ts-mode magik-indent-level)
|
|
(matlab-mode matlab-indent-level)
|
|
(meson-mode meson-indent-basic)
|
|
(mips-mode mips-tab-width)
|
|
(mustache-mode mustache-basic-offset)
|
|
(nasm-mode nasm-basic-offset)
|
|
(nginx-mode nginx-indent-level)
|
|
(nxml-mode nxml-child-indent (nxml-attribute-indent . 2))
|
|
(objc-mode c-basic-offset)
|
|
(octave-mode octave-block-offset)
|
|
(perl-mode perl-indent-level)
|
|
;; No need to change `php-mode-coding-style' value for php-mode
|
|
;; since we run editorconfig later than it resets `c-basic-offset'.
|
|
;; See https://github.com/editorconfig/editorconfig-emacs/issues/116
|
|
;; for details.
|
|
(php-mode c-basic-offset)
|
|
(php-ts-mode php-ts-mode-indent-offset)
|
|
(pike-mode c-basic-offset)
|
|
(protobuf-mode c-basic-offset)
|
|
(ps-mode ps-mode-tab)
|
|
(pug-mode pug-tab-width)
|
|
(puppet-mode puppet-indent-level)
|
|
(python-mode . editorconfig--get-indentation-python-mode)
|
|
(python-ts-mode . editorconfig--get-indentation-python-mode)
|
|
(rjsx-mode js-indent-level sgml-basic-offset)
|
|
(ruby-mode ruby-indent-level)
|
|
(ruby-ts-mode ruby-indent-level)
|
|
(rust-mode rust-indent-offset)
|
|
(rust-ts-mode rust-indent-offset
|
|
rust-ts-mode-indent-offset)
|
|
(rustic-mode rustic-indent-offset)
|
|
(scala-mode scala-indent:step)
|
|
(scss-mode css-indent-offset)
|
|
(sgml-mode sgml-basic-offset)
|
|
(sh-mode sh-basic-offset)
|
|
(slim-mode slim-indent-offset)
|
|
(sml-mode sml-indent-level)
|
|
(svelte-mode svelte-basic-offset)
|
|
(swift-mode swift-mode:basic-offset)
|
|
(terra-mode terra-indent-level)
|
|
(tcl-mode tcl-indent-level
|
|
tcl-continued-indent-level)
|
|
(toml-ts-mode toml-ts-mode-indent-offset)
|
|
(typescript-mode typescript-indent-level)
|
|
(typescript-ts-base-mode typescript-ts-mode-indent-offset)
|
|
(verilog-mode verilog-indent-level
|
|
verilog-indent-level-behavioral
|
|
verilog-indent-level-declaration
|
|
verilog-indent-level-module
|
|
verilog-cexp-indent
|
|
verilog-case-indent)
|
|
(web-mode . editorconfig--get-indentation-web-mode)
|
|
(yaml-mode yaml-indent-offset)
|
|
(yaml-ts-mode yaml-indent-offset)
|
|
(zig-mode zig-indent-offset)
|
|
)
|
|
"Alist of indentation setting methods by modes.
|
|
|
|
This is a fallback used for those modes which don't set
|
|
`editorconfig-indent-size-vars'.
|
|
|
|
Each element should look like (MODE . SETTING) where SETTING
|
|
should obey the same rules as `editorconfig-indent-size-vars'."
|
|
:type '(alist :key-type symbol
|
|
:value-type (choice function
|
|
(repeat
|
|
(choice symbol
|
|
(cons symbol integer)))))
|
|
:risky t)
|
|
|
|
(defcustom editorconfig-trim-whitespaces-mode nil
|
|
"Buffer local minor-mode to use to trim trailing whitespaces.
|
|
|
|
If set, enable that mode when `trim_trailing_whitespace` is set to true.
|
|
Otherwise, use `delete-trailing-whitespace'."
|
|
:type 'symbol)
|
|
|
|
(defvar editorconfig-properties-hash nil
|
|
"Hash object of EditorConfig properties that was enabled for current buffer.
|
|
Set by `editorconfig-apply' and nil if that is not invoked in
|
|
current buffer yet.")
|
|
(make-variable-buffer-local 'editorconfig-properties-hash)
|
|
(put 'editorconfig-properties-hash
|
|
'permanent-local
|
|
t)
|
|
|
|
(defvar editorconfig-lisp-use-default-indent nil
|
|
"Selectively ignore the value of indent_size for Lisp files.
|
|
Prevents `lisp-indent-offset' from being set selectively.
|
|
|
|
nil - `lisp-indent-offset' is always set normally.
|
|
t - `lisp-indent-offset' is never set normally
|
|
(always use default indent for lisps).
|
|
number - `lisp-indent-offset' is not set only if indent_size is
|
|
equal to this number. For example, if this is set to 2,
|
|
`lisp-indent-offset' will not be set only if indent_size is 2.")
|
|
|
|
(define-error 'editorconfig-error
|
|
"Error thrown from editorconfig lib")
|
|
|
|
(defun editorconfig-error (&rest args)
|
|
"Signal an `editorconfig-error'.
|
|
Make a message by passing ARGS to `format-message'."
|
|
(signal 'editorconfig-error (list (apply #'format-message args))))
|
|
|
|
(defun editorconfig-string-integer-p (string)
|
|
"Return non-nil if STRING represents integer."
|
|
(and (stringp string)
|
|
(string-match-p "\\`[0-9]+\\'" string)))
|
|
|
|
(defun editorconfig--get-indentation-web-mode (size)
|
|
`((web-mode-indent-style . 2)
|
|
(web-mode-attr-indent-offset . ,size)
|
|
(web-mode-attr-value-indent-offset . ,size)
|
|
(web-mode-code-indent-offset . ,size)
|
|
(web-mode-css-indent-offset . ,size)
|
|
(web-mode-markup-indent-offset . ,size)
|
|
(web-mode-sql-indent-offset . ,size)
|
|
(web-mode-block-padding . ,size)
|
|
(web-mode-script-padding . ,size)
|
|
(web-mode-style-padding . ,size)))
|
|
|
|
(defun editorconfig--get-indentation-python-mode (size)
|
|
"Vars to set `python-mode' indent size to SIZE."
|
|
`((python-indent-offset . ,size) ;For python.el
|
|
(py-indent-offset . ,size))) ;For python-mode.el
|
|
|
|
(defun editorconfig--get-indentation-latex-mode (size)
|
|
"Vars to set `latex-mode' indent size to SIZE."
|
|
`((tex-indent-basic . ,size)
|
|
(tex-indent-item . ,size)
|
|
(tex-indent-arg . ,(* 2 size))
|
|
;; For AUCTeX
|
|
(TeX-brace-indent-level . ,size)
|
|
(LaTeX-indent-level . ,size)
|
|
(LaTeX-item-indent . ,(- size))))
|
|
|
|
(defun editorconfig--get-indentation-lisp-mode (size)
|
|
"Set indent size to SIZE for Lisp mode(s)."
|
|
(when (cond ((null editorconfig-lisp-use-default-indent) t)
|
|
((eql t editorconfig-lisp-use-default-indent) nil)
|
|
((numberp editorconfig-lisp-use-default-indent)
|
|
(not (eql size editorconfig-lisp-use-default-indent)))
|
|
(t t))
|
|
`((lisp-indent-offset . ,size))))
|
|
|
|
(cl-defun editorconfig--should-set (symbol)
|
|
"Determine if editorconfig should set SYMBOL."
|
|
(display-warning '(editorconfig editorconfig--should-set)
|
|
(format "symbol: %S"
|
|
symbol)
|
|
:debug)
|
|
(when (assq symbol file-local-variables-alist)
|
|
(cl-return-from editorconfig--should-set
|
|
nil))
|
|
|
|
(when (assq symbol dir-local-variables-alist)
|
|
(cl-return-from editorconfig--should-set
|
|
nil))
|
|
|
|
t)
|
|
|
|
(defvar editorconfig-indent-size-vars
|
|
#'editorconfig--default-indent-size-function
|
|
"Rule to use to set a given `indent_size'.
|
|
This should hold the list of variables that need to be set to SIZE
|
|
to tell the indentation code of the current major mode to use a basic
|
|
indentation step of size SIZE.
|
|
It can also take the form of a function, in which case we call it with
|
|
a single SIZE argument (an integer) and it should return a list
|
|
of (VAR . VAL) pairs indicating the variables to set and the values to
|
|
set them to.
|
|
Major modes are expected to set this buffer-locally.")
|
|
|
|
(defun editorconfig--default-indent-size-function (size)
|
|
"Guess which variables to set to for the indentation step to have size SIZE.
|
|
This relies on `editorconfig-indentation-alist' supplemented with a crude
|
|
heuristic for those modes not found there."
|
|
(let ((parents (if (fboundp 'derived-mode-all-parents) ;Emacs-30
|
|
(derived-mode-all-parents major-mode)
|
|
(let ((modes nil)
|
|
(mode major-mode))
|
|
(while mode
|
|
(push mode modes)
|
|
(setq mode (get mode 'derived-mode--parent)))
|
|
(nreverse modes))))
|
|
entry)
|
|
(let ((parents parents))
|
|
(while (and parents (not entry))
|
|
(setq entry (assq (pop parents) editorconfig-indentation-alist))))
|
|
(or
|
|
(when entry
|
|
(let ((rule (cdr entry)))
|
|
;; Filter out settings of unknown vars.
|
|
(delq nil
|
|
(mapcar (lambda (elem)
|
|
(let ((v (car elem)))
|
|
(cond
|
|
((not (symbolp v))
|
|
(message "Unsupported element in `editorconfig-indentation-alist': %S" elem))
|
|
((or (eq 'eval v) (boundp v)) elem))))
|
|
(if (functionp rule)
|
|
(funcall rule size)
|
|
(mapcar (lambda (elem) `(,elem . ,size)) rule))))))
|
|
;; Fallback, let's try and guess.
|
|
(let ((suffixes '("-indent-level" "-basic-offset" "-indent-offset"
|
|
"-block-offset"))
|
|
(guess ()))
|
|
(while (and parents (not guess))
|
|
(let* ((mode (pop parents))
|
|
(modename (symbol-name mode))
|
|
(name (substring modename 0
|
|
(string-match "-mode\\'" modename))))
|
|
(dolist (suffix suffixes)
|
|
(let ((sym (intern-soft (concat name suffix))))
|
|
(when (and sym (boundp sym))
|
|
(setq guess sym))))))
|
|
(when guess `((,guess . ,size))))
|
|
(and (local-variable-p 'smie-rules-function)
|
|
`((smie-indent-basic . ,size))))))
|
|
|
|
(defun editorconfig--get-indentation (props)
|
|
"Get indentation vars according to STYLE, SIZE, and TAB_WIDTH."
|
|
(let ((style (gethash 'indent_style props))
|
|
(size (gethash 'indent_size props))
|
|
(tab_width (gethash 'tab_width props)))
|
|
(when tab_width
|
|
(setq tab_width (string-to-number tab_width)))
|
|
|
|
(setq size
|
|
(cond ((editorconfig-string-integer-p size)
|
|
(string-to-number size))
|
|
((equal size "tab")
|
|
(or tab_width tab-width))
|
|
(t
|
|
nil)))
|
|
`(,@(if tab_width `((tab-width . ,tab_width)))
|
|
|
|
,@(pcase style
|
|
("space" `((indent-tabs-mode . nil)))
|
|
("tab" `((indent-tabs-mode . t))))
|
|
|
|
,@(when (and size (featurep 'evil))
|
|
`((evil-shift-width . ,size)))
|
|
|
|
,@(cond
|
|
((null size) nil)
|
|
((functionp editorconfig-indent-size-vars)
|
|
(funcall editorconfig-indent-size-vars size))
|
|
(t (mapcar (lambda (v) `(,v . ,size)) editorconfig-indent-size-vars))))))
|
|
|
|
(defvar-local editorconfig--apply-coding-system-currently nil
|
|
"Used internally.")
|
|
(put 'editorconfig--apply-coding-system-currently
|
|
'permanent-local
|
|
t)
|
|
|
|
(defun editorconfig-merge-coding-systems (end-of-line charset)
|
|
"Return merged coding system symbol of END-OF-LINE and CHARSET."
|
|
(let ((eol (cond
|
|
((equal end-of-line "lf") 'undecided-unix)
|
|
((equal end-of-line "cr") 'undecided-mac)
|
|
((equal end-of-line "crlf") 'undecided-dos)))
|
|
(cs (cond
|
|
((equal charset "latin1") 'iso-latin-1)
|
|
((equal charset "utf-8") 'utf-8)
|
|
((equal charset "utf-8-bom") 'utf-8-with-signature)
|
|
((equal charset "utf-16be") 'utf-16be-with-signature)
|
|
((equal charset "utf-16le") 'utf-16le-with-signature))))
|
|
(if (and eol cs)
|
|
(merge-coding-systems cs eol)
|
|
(or eol cs))))
|
|
|
|
(cl-defun editorconfig-set-coding-system-revert (end-of-line charset)
|
|
"Set buffer coding system by END-OF-LINE and CHARSET.
|
|
|
|
This function will revert buffer when the coding-system has been changed."
|
|
;; `editorconfig--advice-find-file-noselect' does not use this function
|
|
(let ((coding-system (editorconfig-merge-coding-systems end-of-line
|
|
charset)))
|
|
(display-warning '(editorconfig editorconfig-set-coding-system-revert)
|
|
(format "editorconfig-set-coding-system-revert: buffer-file-name: %S | buffer-file-coding-system: %S | coding-system: %S | apply-currently: %S"
|
|
buffer-file-name
|
|
buffer-file-coding-system
|
|
coding-system
|
|
editorconfig--apply-coding-system-currently)
|
|
:debug)
|
|
(when (memq coding-system '(nil undecided))
|
|
(cl-return-from editorconfig-set-coding-system-revert))
|
|
(when (and buffer-file-coding-system
|
|
(memq buffer-file-coding-system
|
|
(coding-system-aliases (merge-coding-systems coding-system
|
|
buffer-file-coding-system))))
|
|
(cl-return-from editorconfig-set-coding-system-revert))
|
|
(unless (file-readable-p buffer-file-name)
|
|
(set-buffer-file-coding-system coding-system)
|
|
(cl-return-from editorconfig-set-coding-system-revert))
|
|
(unless (memq coding-system
|
|
(coding-system-aliases editorconfig--apply-coding-system-currently))
|
|
;; Revert functions might call `editorconfig-apply' again
|
|
;; FIXME: I suspect `editorconfig--apply-coding-system-currently'
|
|
;; gymnastics is not needed now that we hook into `find-auto-coding'.
|
|
(unwind-protect
|
|
(progn
|
|
(setq editorconfig--apply-coding-system-currently coding-system)
|
|
;; Revert without query if buffer is not modified
|
|
(let ((revert-without-query '(".")))
|
|
(revert-buffer-with-coding-system coding-system)))
|
|
(setq editorconfig--apply-coding-system-currently nil)))))
|
|
|
|
(defun editorconfig--get-trailing-nl (props)
|
|
"Get the vars to require final newline according to PROPS."
|
|
(pcase (gethash 'insert_final_newline props)
|
|
("true"
|
|
;; Keep prefs around how/when the nl is added, if set.
|
|
`((require-final-newline
|
|
. ,(or require-final-newline mode-require-final-newline t))))
|
|
("false"
|
|
`((require-final-newline . nil)))))
|
|
|
|
(defun editorconfig--delete-trailing-whitespace ()
|
|
"Call `delete-trailing-whitespace' unless the buffer is read-only."
|
|
(unless buffer-read-only (delete-trailing-whitespace)))
|
|
|
|
;; Arrange for our (eval . (add-hook ...)) "local var" to be considered safe.
|
|
(defun editorconfig--add-hook-safe-p (exp)
|
|
(equal exp '(add-hook 'before-save-hook
|
|
#'editorconfig--delete-trailing-whitespace nil t)))
|
|
(let ((predicates (get 'add-hook 'safe-local-eval-function)))
|
|
(when (functionp predicates)
|
|
(setq predicates (list predicates)))
|
|
(unless (memq #'editorconfig--add-hook-safe-p predicates)
|
|
(put 'add-hook 'safe-local-eval-function #'editorconfig--add-hook-safe-p)))
|
|
|
|
(defun editorconfig--get-trailing-ws (props)
|
|
"Get vars to trim of trailing whitespace according to PROPS."
|
|
(pcase (gethash 'trim_trailing_whitespace props)
|
|
("true"
|
|
`((eval
|
|
. ,(if editorconfig-trim-whitespaces-mode
|
|
`(,editorconfig-trim-whitespaces-mode 1)
|
|
'(add-hook 'before-save-hook
|
|
#'editorconfig--delete-trailing-whitespace nil t)))))
|
|
("false"
|
|
;; Just do it right away rather than return a (VAR . VAL), which
|
|
;; would be probably more trouble than it's worth.
|
|
(when editorconfig-trim-whitespaces-mode
|
|
(funcall editorconfig-trim-whitespaces-mode 0))
|
|
(remove-hook 'before-save-hook
|
|
#'editorconfig--delete-trailing-whitespace t)
|
|
nil)))
|
|
|
|
(defun editorconfig--get-line-length (props)
|
|
"Get the max line length (`fill-column') to PROPS."
|
|
(let ((length (gethash 'max_line_length props)))
|
|
(when (and (editorconfig-string-integer-p length)
|
|
(> (string-to-number length) 0))
|
|
`((fill-column . ,(string-to-number length))))))
|
|
|
|
(defun editorconfig-call-get-properties-function (filename)
|
|
"Call `editorconfig-core-get-properties-hash' with FILENAME and return result.
|
|
|
|
This function also removes `unset' properties and calls
|
|
`editorconfig-hack-properties-functions'."
|
|
(if (stringp filename)
|
|
(setq filename (expand-file-name filename))
|
|
(editorconfig-error "Invalid argument: %S" filename))
|
|
(let ((props nil))
|
|
(condition-case-unless-debug err
|
|
(setq props (editorconfig-core-get-properties-hash filename))
|
|
(error
|
|
(editorconfig-error "Error from editorconfig-core-get-properties-hash: %S"
|
|
err)))
|
|
(cl-loop for k being the hash-keys of props using (hash-values v)
|
|
when (equal v "unset") do (remhash k props))
|
|
props))
|
|
|
|
(defvar editorconfig-get-local-variables-functions
|
|
'(editorconfig--get-indentation
|
|
editorconfig--get-trailing-nl
|
|
editorconfig--get-trailing-ws
|
|
editorconfig--get-line-length)
|
|
"Special hook run to convert EditorConfig settings to their Emacs equivalent.
|
|
Every function is called with one argument, a hash-table indexed by
|
|
EditorConfig settings represented as symbols and whose corresponding value
|
|
is represented as a string. It should return a list of (VAR . VAL) settings
|
|
where VAR is an ELisp variable and VAL is the value to which it should be set.")
|
|
|
|
(defun editorconfig--get-local-variables (props)
|
|
"Get variables settings according to EditorConfig PROPS."
|
|
(let ((alist ()))
|
|
(run-hook-wrapped 'editorconfig-get-local-variables-functions
|
|
(lambda (fun props)
|
|
(setq alist (append (funcall fun props) alist))
|
|
nil)
|
|
props)
|
|
alist))
|
|
|
|
(defun editorconfig-set-local-variables (props)
|
|
"Set buffer variables according to EditorConfig PROPS."
|
|
(pcase-dolist (`(,var . ,val) (editorconfig--get-local-variables props))
|
|
(if (eq 'eval var)
|
|
(eval val t)
|
|
(when (editorconfig--should-set var)
|
|
(set (make-local-variable var) val)))))
|
|
|
|
(defun editorconfig-major-mode-hook ()
|
|
"Function to run when `major-mode' has been changed.
|
|
|
|
This functions does not reload .editorconfig file, just sets local variables
|
|
again. Changing major mode can reset these variables.
|
|
|
|
This function also executes `editorconfig-after-apply-functions' functions."
|
|
(display-warning '(editorconfig editorconfig-major-mode-hook)
|
|
(format "editorconfig-major-mode-hook: editorconfig-mode: %S, major-mode: %S, -properties-hash: %S"
|
|
(and (boundp 'editorconfig-mode)
|
|
editorconfig-mode)
|
|
major-mode
|
|
editorconfig-properties-hash)
|
|
:debug)
|
|
(when (and (bound-and-true-p editorconfig-mode)
|
|
editorconfig-properties-hash)
|
|
(editorconfig-set-local-variables editorconfig-properties-hash)
|
|
(condition-case err
|
|
(run-hook-with-args 'editorconfig-after-apply-functions editorconfig-properties-hash)
|
|
(error
|
|
(display-warning '(editorconfig editorconfig-major-mode-hook)
|
|
(format "Error while running `editorconfig-after-apply-functions': %S"
|
|
err))))))
|
|
|
|
(defun editorconfig--advice-find-auto-coding (filename &rest _args)
|
|
"Consult `charset' setting of EditorConfig."
|
|
(let ((cs (dlet ((auto-coding-file-name filename))
|
|
(editorconfig--get-coding-system))))
|
|
(when cs (cons cs 'EditorConfig))))
|
|
|
|
(defun editorconfig--advice-find-file-noselect (f filename &rest args)
|
|
"Get EditorConfig properties and apply them to buffer to be visited.
|
|
|
|
This function should be added as an advice function to `find-file-noselect'.
|
|
F is that function, and FILENAME and ARGS are arguments passed to F."
|
|
(let ((props nil)
|
|
(ret nil))
|
|
(condition-case err
|
|
(when (stringp filename)
|
|
(setq props (editorconfig-call-get-properties-function filename)))
|
|
(error
|
|
(display-warning '(editorconfig editorconfig--advice-find-file-noselect)
|
|
(format "Failed to get properties, styles will not be applied: %S"
|
|
err)
|
|
:warning)))
|
|
|
|
(setq ret (apply f filename args))
|
|
|
|
(condition-case err
|
|
(with-current-buffer ret
|
|
(when props
|
|
|
|
;; NOTE: hack-properties-functions cannot affect coding-system value,
|
|
;; because it has to be set before initializing buffers.
|
|
(condition-case err
|
|
(run-hook-with-args 'editorconfig-hack-properties-functions props)
|
|
(error
|
|
(display-warning '(editorconfig editorconfig-hack-properties-functions)
|
|
(format "Error while running editorconfig-hack-properties-functions, abort running hook: %S"
|
|
err)
|
|
:warning)))
|
|
(setq editorconfig-properties-hash props)
|
|
;; When initializing buffer, `editorconfig-major-mode-hook'
|
|
;; will be called before setting `editorconfig-properties-hash', so
|
|
;; execute this explicitly here.
|
|
(editorconfig-set-local-variables props)
|
|
|
|
(condition-case err
|
|
(run-hook-with-args 'editorconfig-after-apply-functions props)
|
|
(error
|
|
(display-warning '(editorconfig editorconfig--advice-find-file-noselect)
|
|
(format "Error while running `editorconfig-after-apply-functions': %S"
|
|
err))))))
|
|
(error
|
|
(display-warning '(editorconfig editorconfig--advice-find-file-noselect)
|
|
(format "Error while setting variables from EditorConfig: %S" err))))
|
|
ret))
|
|
|
|
(defvar editorconfig--getting-coding-system nil)
|
|
|
|
(defun editorconfig--get-coding-system (&optional _size)
|
|
"Return the coding system to use according to EditorConfig.
|
|
Meant to be used on `auto-coding-functions'."
|
|
(defvar auto-coding-file-name) ;; Emacs≥30
|
|
(when (and (stringp auto-coding-file-name)
|
|
(file-name-absolute-p auto-coding-file-name)
|
|
;; Don't recurse infinitely.
|
|
(not (member auto-coding-file-name
|
|
editorconfig--getting-coding-system)))
|
|
(let* ((editorconfig--getting-coding-system
|
|
(cons auto-coding-file-name editorconfig--getting-coding-system))
|
|
(props (editorconfig-call-get-properties-function
|
|
auto-coding-file-name)))
|
|
(editorconfig-merge-coding-systems (gethash 'end_of_line props)
|
|
(gethash 'charset props)))))
|
|
|
|
(defun editorconfig--get-dir-local-variables ()
|
|
"Return the directory local variables specified via EditorConfig.
|
|
Meant to be used on `hack-dir-local-get-variables-functions'."
|
|
(when (stringp buffer-file-name)
|
|
(let* ((props (editorconfig-call-get-properties-function buffer-file-name))
|
|
(alist (editorconfig--get-local-variables props)))
|
|
;; FIXME: If there's `/foo/.editorconfig', `/foo/bar/.dir-locals.el',
|
|
;; and `/foo/bar/baz/.editorconfig', it would be nice to return two
|
|
;; pairs here, so that hack-dir-local can give different priorities
|
|
;; to the `/foo/.editorconfig' settings compared to those of
|
|
;; `/foo/bar/baz/.editorconfig', but we can't just convert the
|
|
;; settings from each file individually and let hack-dir-local merge
|
|
;; them because hack-dir-local doesn't have the notion of "unset",
|
|
;; and because the conversion of `indent_size' depends on `tab_width'.
|
|
(when alist
|
|
(cons
|
|
(file-name-directory (editorconfig-core-get-nearest-editorconfig
|
|
buffer-file-name))
|
|
alist)))))
|
|
|
|
;;;###autoload
|
|
(define-minor-mode editorconfig-mode
|
|
"Toggle EditorConfig feature."
|
|
:global t
|
|
(if (boundp 'hack-dir-local-get-variables-functions) ;Emacs≥30
|
|
(if editorconfig-mode
|
|
(progn
|
|
(add-hook 'hack-dir-local-get-variables-functions
|
|
;; Give them slightly lower precedence than settings from
|
|
;; `dir-locals.el'.
|
|
#'editorconfig--get-dir-local-variables t)
|
|
;; `auto-coding-functions' also exists in Emacs<30 but without
|
|
;; access to the file's name via `auto-coding-file-name'.
|
|
(add-hook 'auto-coding-functions
|
|
#'editorconfig--get-coding-system))
|
|
(remove-hook 'hack-dir-local-get-variables-functions
|
|
#'editorconfig--get-dir-local-variables)
|
|
(remove-hook 'auto-coding-functions
|
|
#'editorconfig--get-coding-system))
|
|
;; Emacs<30
|
|
(let ((modehooks '(prog-mode-hook
|
|
text-mode-hook
|
|
;; Some modes call `kill-all-local-variables' in their init
|
|
;; code, which clears some values set by editorconfig.
|
|
;; For those modes, editorconfig-apply need to be called
|
|
;; explicitly through their hooks.
|
|
rpm-spec-mode-hook)))
|
|
(if editorconfig-mode
|
|
(progn
|
|
(advice-add 'find-file-noselect :around #'editorconfig--advice-find-file-noselect)
|
|
(advice-add 'find-auto-coding :after-until
|
|
#'editorconfig--advice-find-auto-coding)
|
|
(dolist (hook modehooks)
|
|
(add-hook hook
|
|
#'editorconfig-major-mode-hook
|
|
t)))
|
|
(advice-remove 'find-file-noselect #'editorconfig--advice-find-file-noselect)
|
|
(advice-remove 'find-auto-coding
|
|
#'editorconfig--advice-find-auto-coding)
|
|
(dolist (hook modehooks)
|
|
(remove-hook hook #'editorconfig-major-mode-hook))))))
|
|
|
|
|
|
;; (defconst editorconfig--version
|
|
;; (eval-when-compile
|
|
;; (require 'lisp-mnt)
|
|
;; (declare-function lm-version "lisp-mnt" nil)
|
|
;; (lm-version))
|
|
;; "EditorConfig version.")
|
|
|
|
;; ;;;###autoload
|
|
;; (defun editorconfig-version (&optional show-version)
|
|
;; "Get EditorConfig version as string.
|
|
;;
|
|
;; If called interactively or if SHOW-VERSION is non-nil, show the
|
|
;; version in the echo area and the messages buffer."
|
|
;; (interactive (list t))
|
|
;; (let ((version-full
|
|
;; (if (fboundp 'package-get-version)
|
|
;; (package-get-version)
|
|
;; (let* ((version
|
|
;; (with-temp-buffer
|
|
;; (require 'find-func)
|
|
;; (declare-function find-library-name "find-func" (library))
|
|
;; (insert-file-contents (find-library-name "editorconfig"))
|
|
;; (require 'lisp-mnt)
|
|
;; (declare-function lm-version "lisp-mnt" nil)
|
|
;; (lm-version)))
|
|
;; (pkg (and (eval-and-compile (require 'package nil t))
|
|
;; (cadr (assq 'editorconfig
|
|
;; package-alist))))
|
|
;; (pkg-version (and pkg (package-version-join
|
|
;; (package-desc-version pkg)))))
|
|
;; (if (and pkg-version
|
|
;; (not (string= version pkg-version)))
|
|
;; (concat version "-" pkg-version)
|
|
;; version)))))
|
|
;; (when show-version
|
|
;; (message "EditorConfig Emacs v%s" version-full))
|
|
;; version-full))
|
|
|
|
(provide 'editorconfig)
|
|
;;; editorconfig.el ends here
|