tudattr/dotfiles
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

Added emacs prelude and config

Browse Source
This commit is contained in:
TuDatTr
2018-01-09 04:06:05 +01:00
parent 87a671756a
commit 505d3526b8
1129 changed files with 308314 additions and 5398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig-autoloads.el Normal file
View File

@@ -0,0 +1,127 @@
;;; editorconfig-autoloads.el --- automatically extracted autoloads
;;
;;; Code:
(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
;;;### (autoloads nil "editorconfig" "editorconfig.el" (23122 58400
;;;;;; 22368 445000))
;;; Generated autoloads from editorconfig.el
(autoload 'editorconfig-find-current-editorconfig "editorconfig" "\
Find the closest .editorconfig file for current file.
\(fn)" t nil)
(autoload 'editorconfig-display-current-properties "editorconfig" "\
Display EditorConfig properties extracted for current buffer.
\(fn)" t nil)
(autoload 'editorconfig-apply "editorconfig" "\
Apply EditorConfig properties for current buffer.
This function ignores `editorconfig-exclude-modes' and always
applies available properties.
\(fn)" t nil)
(defvar editorconfig-mode nil "\
Non-nil if Editorconfig mode is enabled.
See the `editorconfig-mode' command
for a description of this minor mode.
Setting this variable directly does not take effect;
either customize it (see the info node `Easy Customization')
or call the function `editorconfig-mode'.")
(custom-autoload 'editorconfig-mode "editorconfig" nil)
(autoload 'editorconfig-mode "editorconfig" "\
Toggle EditorConfig feature.
When enabled EditorConfig properties will be applied to buffers
when first visiting files or changing major modes if the major
mode is not listed in `editorconfig-exclude-modes'.
\(fn &optional ARG)" t nil)
;;;***
;;;### (autoloads nil "editorconfig-conf-mode" "editorconfig-conf-mode.el"
;;;;;; (23122 58400 5701 696000))
;;; Generated autoloads from editorconfig-conf-mode.el
(autoload 'editorconfig-conf-mode "editorconfig-conf-mode" "\
Major mode for editing .editorconfig files.
\(fn)" t nil)
(add-to-list 'auto-mode-alist '("/\\.editorconfig\\'" . editorconfig-conf-mode))
;;;***
;;;### (autoloads nil "editorconfig-core" "editorconfig-core.el"
;;;;;; (23122 58399 999034 996000))
;;; Generated autoloads from editorconfig-core.el
(autoload 'editorconfig-core-get-nearest-editorconfig "editorconfig-core" "\
Return path to .editorconfig file that is closest to DIRECTORY.
\(fn DIRECTORY)" nil nil)
(autoload 'editorconfig-core-get-properties "editorconfig-core" "\
Get EditorConfig properties for FILE.
If FILE is not given, use currently visiting file.
Give CONFNAME for basename of config file other than .editorconfig.
If need to specify config format version, give CONFVERSION.
This functions returns alist of properties. Each element will look like
'(KEY . VALUE) .
\(fn &optional FILE CONFNAME CONFVERSION)" nil nil)
(autoload 'editorconfig-core-get-properties-hash "editorconfig-core" "\
Get EditorConfig properties for FILE.
If FILE is not given, use currently visiting file.
Give CONFNAME for basename of config file other than .editorconfig.
If need to specify config format version, give CONFVERSION.
This function is almost same as `editorconfig-core-get-properties', but returns
hash object instead.
\(fn &optional FILE CONFNAME CONFVERSION)" nil nil)
;;;***
;;;### (autoloads nil "editorconfig-fnmatch" "editorconfig-fnmatch.el"
;;;;;; (23122 58399 989034 947000))
;;; Generated autoloads from editorconfig-fnmatch.el
(autoload 'editorconfig-fnmatch-p "editorconfig-fnmatch" "\
Test whether NAME match PATTERN.
Matching ignores case if `case-fold-search' is non-nil.
PATTERN should be a shell glob pattern, and some zsh-like wildcard matchings can
be used:
* Matches any string of characters, except path separators (/)
** Matches any string of characters
? Matches any single character
\[name] Matches any single character in name
\[^name] Matches any single character not in name
{s1,s2,s3} Matches any of the strings given (separated by commas)
{min..max} Matches any number between min and max
\(fn NAME PATTERN)" nil nil)
;;;***
;;;### (autoloads nil nil ("editorconfig-core-handle.el" "editorconfig-pkg.el")
;;;;;; (23122 58400 29035 145000))
;;;***
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; End:
;;; editorconfig-autoloads.el ends here

94
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig-conf-mode.el Normal file
View File

@@ -0,0 +1,94 @@
;;; editorconfig-conf-mode.el --- Major mode for editing .editorconfig files
;; Copyright (C) 2011-2017 EditorConfig Team
;; Author: EditorConfig Team <editorconfig@googlegroups.com>
;; URL: https://github.com/editorconfig/editorconfig-emacs#readme
;; See
;; https://github.com/editorconfig/editorconfig-emacs/graphs/contributors
;; or the CONTRIBUTORS file for the list of contributors.
;; This file is part of EditorConfig Emacs Plugin.
;; EditorConfig Emacs Plugin 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.
;; EditorConfig Emacs Plugin 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
;; EditorConfig Emacs Plugin. If not, see <https://www.gnu.org/licenses/>.
;;; Commentary:
;; Major mode for editing .editorconfig files.
;;; Code:
(require 'conf-mode)
(defvar editorconfig-conf-mode-syntax-table
(let ((table (make-syntax-table conf-unix-mode-syntax-table)))
(modify-syntax-entry ?\; "<" table)
table)
"Syntax table in use in `editorconfig-conf-mode' buffers.")
;;;###autoload
(define-derived-mode editorconfig-conf-mode conf-unix-mode "Conf[EditorConfig]"
"Major mode for editing .editorconfig files."
(set-variable 'indent-line-function 'indent-relative)
(let ((key-property-list
'("charset"
"end_of_line"
"file_type_emacs"
"indent_size"
"indent_style"
"insert_final_newline"
"max_line_length"
"root"
"tab_width"
"trim_trailing_whitespace"))
(key-value-list
'("true"
"false"
"lf"
"cr"
"crlf"
"space"
"tab"
"latin1"
"utf-8"
"utf-8-bom"
"utf-16be"
"utf-16le"))
(font-lock-value
'(("^[ \t]*\\[\\(.+?\\)\\]" 1 font-lock-type-face)
("^[ \t]*\\(.+?\\)[ \t]*[=:]" 1 font-lock-variable-name-face))))
;; Highlight all key values
(dolist (key-value key-value-list)
(add-to-list
'font-lock-value
`(,(format "[=:][ \t]*\\(%s\\)\\([ \t]\\|$\\)" key-value)
1 font-lock-constant-face)))
;; Highlight all key properties
(dolist (key-property key-property-list)
(add-to-list
'font-lock-value
`(,(format "^[ \t]*\\(%s\\)[ \t]*[=:]" key-property)
1 font-lock-builtin-face)))
(conf-mode-initialize "#" font-lock-value)))
;;;###autoload
(add-to-list 'auto-mode-alist
'("/\\.editorconfig\\'" . editorconfig-conf-mode))
(provide 'editorconfig-conf-mode)
;;; editorconfig-conf-mode.el ends here

BIN
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig-conf-mode.elc Normal file
View File

Binary file not shown.

222
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig-core-handle.el Normal file
View File

@@ -0,0 +1,222 @@
;;; editorconfig-core-handle.el --- Handle Class for EditorConfig File
;; Copyright (C) 2011-2017 EditorConfig Team
;; Author: EditorConfig Team <editorconfig@googlegroups.com>
;; URL: https://github.com/editorconfig/editorconfig-emacs#readme
;; See
;; https://github.com/editorconfig/editorconfig-emacs/graphs/contributors
;; or the CONTRIBUTORS file for the list of contributors.
;; This file is part of EditorConfig Emacs Plugin.
;; EditorConfig Emacs Plugin 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.
;; EditorConfig Emacs Plugin 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
;; EditorConfig Emacs Plugin. If not, see <https://www.gnu.org/licenses/>.
;;; Commentary:
;; Handle class for EditorConfig config file. This library is used internally
;; from editorconfig-core.el .
;;; Code:
(require 'editorconfig-fnmatch)
;; For cl-defstruct
(require 'cl-lib)
(defvar editorconfig-core-handle--cache-hash
(make-hash-table :test 'equal)
"Hash of EditorConfig filename and its `editorconfig-core-handle' instance.")
(cl-defstruct editorconfig-core-handle
;; Alist of top propetties
;; e.g. (("root" . "true"))
(top-prop nil)
;; Alist of properties
;; Key: Section name
;; Value: Alist of properties for each section name
;; e.g.
;; (
;; ("*" ("end_of_line" . "lf") ("indent_style" . "space"))
;; ("Makefile" ("indent_style" . "tab"))
;; )
(prop nil)
;; e.g. (22310 59113 203882 991000)
(mtime nil)
;; e.g. "/home/a/b/.editorconfig"
(path nil))
(defun editorconfig-core-handle (conf)
"Return EditorConfig handle for CONF, which should be a file path.
If CONF does not exist return nil."
(when (file-readable-p conf)
(let ((cached (gethash conf
editorconfig-core-handle--cache-hash))
(mtime (nth 5
(file-attributes conf))))
(if (and cached
(equal (editorconfig-core-handle-mtime cached)
mtime))
cached
(let ((parsed (editorconfig-core-handle--parse-file conf)))
(puthash conf
(make-editorconfig-core-handle :top-prop (car parsed)
:prop (cdr parsed)
:mtime mtime
:path conf)
editorconfig-core-handle--cache-hash))))))
(defun editorconfig-core-handle-root-p (handle)
"Return non-nil if HANDLE represent root EditorConfig file.
If HANDLE is nil return nil."
(when handle
(string-equal "true"
(downcase (or (cdr (assoc "root"
(editorconfig-core-handle-top-prop handle)))
"")))))
(defun editorconfig-core-handle-get-properties (handle file)
"Return list of alist of properties from HANDLE for FILE.
The list returned will be ordered by the lines they appear.
If HANDLE is nil return nil."
(when handle
(mapcar (lambda (prop) (copy-alist (cdr prop)))
(cl-remove-if-not (lambda (prop)
(editorconfig-core-handle--fnmatch-p file
(car prop)
(file-name-directory (editorconfig-core-handle-path handle))))
(editorconfig-core-handle-prop handle)))))
(defun editorconfig-core-handle--fnmatch-p (name pattern dir)
"Return non-nil if NAME match PATTERN.
If pattern has slash, pattern should be relative to DIR.
This function is a fnmatch with a few modification for EditorConfig usage."
(if (string-match-p "/" pattern)
(let ((pattern (replace-regexp-in-string "^/"
""
pattern))
(dir (file-name-as-directory dir)))
(editorconfig-fnmatch-p name
(concat dir
pattern)))
(editorconfig-fnmatch-p name
(concat "**/"
pattern))))
(defsubst editorconfig-core-handle--string-trim (str)
"Remove leading and trailing whitespace from STR."
(replace-regexp-in-string "[ \t\n\r]+\\'"
""
(replace-regexp-in-string "\\`[ \t\n\r]+"
""
str)))
(defun editorconfig-core-handle--parse-file (conf)
"Parse EditorConfig file CONF.
This function returns cons of its top properties alist and
alist of patterns and its properties alist.
The list returned will be ordered by the lines they appear.
If CONF is not found return nil."
(when (file-readable-p conf)
(with-temp-buffer
;; NOTE: Use this instead of insert-file-contents-literally to enable
;; code conversion
(insert-file-contents conf)
(goto-char (point-min))
(let ((point-max (point-max))
(all-props ())
(top-props nil)
;; String of current line
(line "")
;; nil when pattern not appeared yet, "" when pattern is empty ("[]")
(pattern nil)
;; Alist of properties for current PATTERN
(props ())
;; Current line num
(current-line-number 1)
)
(while (not (eq (point) point-max))
(setq line
(buffer-substring-no-properties (point-at-bol)
(point-at-eol)))
(setq line
(replace-regexp-in-string "\\(^\\| \\)\\(#\\|;\\).*$"
""
(editorconfig-core-handle--string-trim line)))
(cond
((string-equal "" line)
nil)
((string-match "^\\[\\(.*\\)\\]$"
line)
(when pattern
(setq all-props
`(,@all-props (,pattern . ,props)))
(setq props nil))
(setq pattern (match-string 1 line)))
(t
(let ((idx (string-match "=\\|:"
line)))
(unless idx
(error "Error while reading config file: %s:%d:\n %s\n"
conf
current-line-number
line))
(let (
(key (downcase (editorconfig-core-handle--string-trim
(substring line
0
idx))))
(value (editorconfig-core-handle--string-trim
(substring line
(1+ idx)))))
(when (and (< (length key) 51)
(< (length value) 256))
(if pattern
(when (< (length pattern) 4097)
(setq props
`(,@props (,key . ,value))))
(setq top-props
`(,@top-props (,key . ,value))))))))
)
(setq current-line-number
(1+ current-line-number))
;; Use this code instead of goto-line for Lisp program
(goto-char (point-min))
(forward-line (1- current-line-number))
)
(when pattern
(setq all-props
`(,@all-props (,pattern . ,props))))
(cons top-props
all-props)))))
(provide 'editorconfig-core-handle)
;;; editorconfig-core-handle.el ends here

BIN
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig-core-handle.elc Normal file
View File

Binary file not shown.

210
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig-core.el Normal file
View File

@@ -0,0 +1,210 @@
;;; editorconfig-core.el --- EditorConfig Core library in Emacs Lisp
;; Copyright (C) 2011-2017 EditorConfig Team
;; Author: EditorConfig Team <editorconfig@googlegroups.com>
;; URL: https://github.com/editorconfig/editorconfig-emacs#readme
;; See
;; https://github.com/editorconfig/editorconfig-emacs/graphs/contributors
;; or the CONTRIBUTORS file for the list of contributors.
;; This file is part of EditorConfig Emacs Plugin.
;; EditorConfig Emacs Plugin 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.
;; EditorConfig Emacs Plugin 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
;; EditorConfig Emacs Plugin. If not, see <https://www.gnu.org/licenses/>.
;;; Commentary:
;; This library is one implementation of EditorConfig Core, which parses
;; .editorconfig files and returns properties for given files.
;; This can be used in place of, for example, editorconfig-core-c.
;; Use from EditorConfig Emacs Plugin
;; Emacs plugin (v0.5 or later) can utilize this implementation.
;; By default, the plugin first search for any EditorConfig executable,
;; and fallback to this library if not found.
;; If you always want to use this library, add following lines to your init.el:
;; (setq editorconfig-get-properties-function
;; 'editorconfig-core-get-properties-hash)
;; Functions
;; editorconfig-core-get-properties (&optional file confname confversion)
;; Get EditorConfig properties for FILE.
;; If FILE is not given, use currently visiting file.
;; Give CONFNAME for basename of config file other than .editorconfig.
;; If need to specify config format version, give CONFVERSION.
;; This functions returns alist of properties. Each element will look like
;; (KEY . VALUE) .
;; editorconfig-core-get-properties-hash (&optional file confname confversion)
;; Get EditorConfig properties for FILE.
;; This function is almost same as `editorconfig-core-get-properties', but
;; returns hash object instead.
;;; Code:
(require 'cl-lib)
(require 'editorconfig-core-handle)
(defconst editorconfig-core-version
"0.7.11"
"EditorConfig core version.")
(defun editorconfig-core--remove-duplicate (alist)
"Remove duplicated keys in ALIST.
If same keys are found in ALIST multiple times, the latter ones take precedence.
For example, when ALIST is
'((a 1) (b 2) (c 3) (b 4))
then the result will be
'((a 1) (b 4) (c 3)) ."
(let ((result ()))
(dolist (e alist)
(let ((pair (assoc (car e)
result)))
(if pair
(setcdr pair
(cdr e))
(setq result
`(,@result ,e)))))
result))
(defun editorconfig-core--get-handles (dir confname &optional result)
"Get list of EditorConfig handlers for DIR from CONFNAME.
In the resulting list, the handle for root config file comes first, and the
nearest comes last.
The list may contains nil when no file was found for directories.
RESULT is used internally and normally should not be used."
(setq dir (expand-file-name dir))
(let ((handle (editorconfig-core-handle (concat (file-name-as-directory dir)
confname)))
(parent (file-name-directory (directory-file-name dir))))
(if (or (string= parent
dir)
(and handle
(editorconfig-core-handle-root-p handle)))
(cl-remove-if-not 'identity
(cons handle result))
(editorconfig-core--get-handles parent
confname
(cons handle
result)))))
;;;###autoload
(defun editorconfig-core-get-nearest-editorconfig (directory)
"Return path to .editorconfig file that is closest to DIRECTORY."
(let ((handle (car (last (editorconfig-core--get-handles directory
".editorconfig")))))
(when handle
(editorconfig-core-handle-path handle))))
;;;###autoload
(defun editorconfig-core-get-properties (&optional file confname confversion)
"Get EditorConfig properties for FILE.
If FILE is not given, use currently visiting file.
Give CONFNAME for basename of config file other than .editorconfig.
If need to specify config format version, give CONFVERSION.
This functions returns alist of properties. Each element will look like
'(KEY . VALUE) ."
(setq file (expand-file-name (or file
buffer-file-name
(error "FILE is not given and `buffer-file-name' is nil"))))
(setq confname (or confname
".editorconfig"))
(setq confversion (or confversion
"0.12.0"))
(let ((result (editorconfig-core--remove-duplicate
(apply 'append
(mapcar (lambda (handle)
(apply 'append
(editorconfig-core-handle-get-properties handle
file)))
(editorconfig-core--get-handles (file-name-directory file)
confname))))))
(dolist (key '("end_of_line" "indent_style" "indent_size"
"insert_final_newline" "trim_trailing_whitespace" "charset"))
(let ((pair (assoc key
result)))
(when pair
(setcdr pair
(downcase (cdr pair))))))
;; Add indent_size property
(let ((p-indent-size (assoc "indent_size" result))
(p-indent-style (assoc "indent_style" result)))
(when (and (not p-indent-size)
(string= (cdr p-indent-style) "tab")
;; If VERSION < 0.9.0, indent_size should have no default value
(version<= "0.9.0"
confversion))
(setq result
`(,@result ("indent_size" . "tab")))))
;; Add tab_width property
(let ((p-indent-size (assoc "indent_size" result))
(p-tab-width (assoc "tab_width" result)))
(when (and p-indent-size
(not p-tab-width)
(not (string= (cdr p-indent-size) "tab")))
(setq result
`(,@result ("tab_width" . ,(cdr p-indent-size))))))
;; Update indent-size property
(let ((p-indent-size (assoc "indent_size" result))
(p-tab-width (assoc "tab_width" result)))
(when (and p-indent-size
p-tab-width
(string= (cdr p-indent-size) "tab"))
(setcdr p-indent-size (cdr p-tab-width))))
result))
;;;###autoload
(defun editorconfig-core-get-properties-hash (&optional file confname confversion)
"Get EditorConfig properties for FILE.
If FILE is not given, use currently visiting file.
Give CONFNAME for basename of config file other than .editorconfig.
If need to specify config format version, give CONFVERSION.
This function is almost same as `editorconfig-core-get-properties', but returns
hash object instead."
(let ((result (editorconfig-core-get-properties file
confname
confversion))
(hash (make-hash-table :test 'equal)))
(dolist (prop result)
(puthash (intern (car prop))
(cdr prop)
hash))
hash))
(provide 'editorconfig-core)
;;; editorconfig-core.el ends here

BIN
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig-core.elc Normal file
View File

Binary file not shown.

305
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig-fnmatch.el Normal file
View File

@@ -0,0 +1,305 @@
;;; editorconfig-fnmatch.el --- Glob pattern matching in Emacs lisp
;; Copyright (C) 2011-2017 EditorConfig Team
;; Author: EditorConfig Team <editorconfig@googlegroups.com>
;; URL: https://github.com/editorconfig/editorconfig-emacs#readme
;; See
;; https://github.com/editorconfig/editorconfig-emacs/graphs/contributors
;; or the CONTRIBUTORS file for the list of contributors.
;; This file is part of EditorConfig Emacs Plugin.
;; EditorConfig Emacs Plugin 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.
;; EditorConfig Emacs Plugin 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
;; EditorConfig Emacs Plugin. If not, see <https://www.gnu.org/licenses/>.
;;; Commentary:
;; editorconfig-fnmatch.el provides a fnmatch implementation with a few
;; extensions.
;; The main usage of this library is glob pattern matching for EditorConfig, but
;; it can also act solely.
;; editorconfig-fnmatch-p (name pattern)
;; Test whether NAME match PATTERN.
;; PATTERN should be a shell glob pattern, and some zsh-like wildcard matchings
;; can be used:
;; * Matches any string of characters, except path separators (/)
;; ** Matches any string of characters
;; ? Matches any single character
;; [name] Matches any single character in name
;; [^name] Matches any single character not in name
;; {s1,s2,s3} Matches any of the strings given (separated by commas)
;; {min..max} Matches any number between min and max
;; This library is a port from editorconfig-core-py library.
;; https://github.com/editorconfig/editorconfig-core-py/blob/master/editorconfig/fnmatch.py
;;; Code:
(require 'cl-lib)
(defvar editorconfig-fnmatch--cache-hash
(make-hash-table :test 'equal)
"Cache of shell pattern and its translation.")
(defconst editorconfig-fnmatch--left-brace-regexp
"\\(^\\|[^\\]\\){"
"Regular expression for left brace ({).")
(defconst editorconfig-fnmatch--right-brace-regexp
"\\(^\\|[^\\]\\)}"
"Regular expression for right brace (}).")
(defconst editorconfig-fnmatch--numeric-range-regexp
"\\([+-]?[0-9]+\\)\\.\\.\\([+-]?[0-9]+\\)"
"Regular expression for numaric range (like {-3..+3}).")
(defun editorconfig-fnmatch--match-num (regexp string)
"Return how many times REGEXP is found in STRING."
(let ((num 0))
;; START arg does not work as expected in this case
(while (string-match regexp string)
(setq num (1+ num)
string (substring string (match-end 0))))
num))
;;;###autoload
(defun editorconfig-fnmatch-p (name pattern)
"Test whether NAME match PATTERN.
Matching ignores case if `case-fold-search' is non-nil.
PATTERN should be a shell glob pattern, and some zsh-like wildcard matchings can
be used:
* Matches any string of characters, except path separators (/)
** Matches any string of characters
? Matches any single character
[name] Matches any single character in name
[^name] Matches any single character not in name
{s1,s2,s3} Matches any of the strings given (separated by commas)
{min..max} Matches any number between min and max"
(let* ((translated (editorconfig-fnmatch-translate pattern))
(re (car translated))
(num-groups (nth 1 translated))
(match (string-match re name))
(num-groups-len (length num-groups))
(pattern-matched t))
(when match
(let (num-group matched-num-str matched-num min-num max-num)
(dotimes (index num-groups-len)
(setq num-group (nth index num-groups))
(setq matched-num-str (match-string (1+ index)
name)
min-num (car num-group)
max-num (nth 1 num-group))
(setq matched-num (string-to-number matched-num-str))
(when (or (= (aref matched-num-str 0)
?0)
(< matched-num min-num)
(< max-num matched-num))
(setq pattern-matched nil))))
pattern-matched)))
;;(editorconfig-fnmatch-translate "{a,{-3..3}}.js")
;;(editorconfig-fnmatch-p "1.js" "{a,{-3..3}}.js")
(defun editorconfig-fnmatch-translate (pattern)
"Translate a shell PATTERN to a regular expression.
Translation result will be cached, so same translation will not be done twice."
(let ((cached (gethash pattern
editorconfig-fnmatch--cache-hash)))
(or cached
(puthash pattern
(editorconfig-fnmatch--do-translate pattern)
editorconfig-fnmatch--cache-hash))))
(defun editorconfig-fnmatch--do-translate (pattern &optional nested)
"Translate a shell PATTERN to a regular expression.
Set NESTED to t when this function is called from itself.
This function is called from `editorconfig-fnmatch-translate', when no cached
translation is found for PATTERN."
(let ((index 0)
(length (length pattern))
(brace-level 0)
(in-brackets nil)
;; List of strings of resulting regexp
(result ())
(is-escaped nil)
(matching-braces (= (editorconfig-fnmatch--match-num
editorconfig-fnmatch--left-brace-regexp
pattern)
(editorconfig-fnmatch--match-num
editorconfig-fnmatch--right-brace-regexp
pattern)))
(numeric-groups ())
current-char
pos
has-slash
has-comma
num-range)
(while (< index length)
(if (and (not is-escaped)
(string-match "[^]\\*?[{},/\\-]+"
;;(string-match "[^]\\*?[{},/\\-]+" "?.a")
pattern
index)
(eq index (match-beginning 0)))
(setq result `(,@result ,(regexp-quote (match-string 0 pattern)))
index (match-end 0)
is-escaped nil)
(setq current-char (aref pattern index)
index (1+ index))
(cl-case current-char
(?*
(setq pos index)
(if (and (< pos length)
(= (aref pattern pos) ?*))
(setq result `(,@result ".*"))
(setq result `(,@result "[^/]*"))))
(??
(setq result `(,@result ".")))
(?\[
(if in-brackets
(setq result `(,@result "\\["))
(setq pos index
has-slash nil)
(while (and (< pos length)
(not (= (aref pattern pos) ?\]))
(not has-slash))
(if (and (= (aref pattern pos) ?/)
(not (= (aref pattern (- pos 1)) ?\\)))
(setq has-slash t)
(setq pos (1+ pos))))
(if has-slash
(setq result `(,@result ,(concat "\\["
(substring pattern
index
(1+ pos))
"\\]"))
index (+ pos 2))
(if (and (< index length)
(memq (aref pattern index)
'(?! ?^)))
(setq index (1+ index)
result `(,@result "[^"))
(setq result `(,@result "[")))
(setq in-brackets t))))
(?-
(if in-brackets
(setq result `(,@result "-"))
(setq result `(,@result "\\-"))))
(?\]
(setq result `(,@result "]")
in-brackets nil))
(?{
(setq pos index
has-comma nil)
(while (and (or (and (< pos length)
(not (= (aref pattern pos)
?})))
is-escaped)
(not has-comma))
(if (and (eq (aref pattern pos)
?,)
(not is-escaped))
(setq has-comma t)
(setq is-escaped (and (eq (aref pattern pos)
?\\)
(not is-escaped))
pos (1+ pos))))
(if (and (not has-comma)
(< pos length))
(let ((pattern-sub (substring pattern index pos)))
(setq num-range (string-match editorconfig-fnmatch--numeric-range-regexp
pattern-sub))
(if num-range
(setq numeric-groups `(,@numeric-groups ,(mapcar 'string-to-number
(list (match-string 1
pattern-sub)
(match-string 2
pattern-sub))))
result `(,@result "\\([+-]?[0-9]+\\)"))
(let ((inner (editorconfig-fnmatch--do-translate pattern-sub t)))
(setq result `(,@result ,(format "{%s}"
(car inner)))
numeric-groups `(,@numeric-groups ,@(nth 1 inner)))))
(setq index (1+ pos)))
(if matching-braces
(setq result `(,@result "\\(?:")
brace-level (1+ brace-level))
(setq result `(,@result "{")))))
(?,
(if (and (> brace-level 0)
(not is-escaped))
(setq result `(,@result "\\|"))
(setq result `(,@result "\\,"))))
(?}
(if (and (> brace-level 0)
(not is-escaped))
(setq result `(,@result "\\)")
brace-level (- brace-level 1))
(setq result `(,@result "}"))))
(?/
(if (and (<= (+ index 3)
(length pattern))
(string= (substring pattern index (+ index 3))
"**/"))
(setq result `(,@result "\\(?:/\\|/.*/\\)")
index (+ index 3))
(setq result `(,@result "/"))))
(t
(unless (= current-char
?\\)
(setq result `(,@result ,(regexp-quote (char-to-string current-char)))))))
(if (= current-char ?\\)
(progn (when is-escaped
(setq result `(,@result "\\\\")))
(setq is-escaped (not is-escaped)))
(setq is-escaped nil))))
(unless nested
(setq result `("^" ,@result "\\'")))
(list (mapconcat 'identity
result
"")
numeric-groups)))
(provide 'editorconfig-fnmatch)
;;; editorconfig-fnmatch.el ends here

BIN
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig-fnmatch.elc Normal file
View File

Binary file not shown.

6
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig-pkg.el Normal file
View File

@@ -0,0 +1,6 @@
(define-package "editorconfig" "20171208.2036" "EditorConfig Emacs Plugin"
'((cl-lib "0.5"))
:url "https://github.com/editorconfig/editorconfig-emacs#readme")
;; Local Variables:
;; no-byte-compile: t
;; End:

569
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig.el Normal file
View File

@@ -0,0 +1,569 @@
;;; editorconfig.el --- EditorConfig Emacs Plugin
;; Copyright (C) 2011-2017 EditorConfig Team
;; Author: EditorConfig Team <editorconfig@googlegroups.com>
;; Version: 0.7.11
;; URL: https://github.com/editorconfig/editorconfig-emacs#readme
;; Package-Requires: ((cl-lib "0.5"))
;; See
;; https://github.com/editorconfig/editorconfig-emacs/graphs/contributors
;; or the CONTRIBUTORS file for the list of contributors.
;; This file is part of EditorConfig Emacs Plugin.
;; EditorConfig Emacs Plugin 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.
;; EditorConfig Emacs Plugin 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
;; EditorConfig Emacs Plugin. 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.
;;; Code:
(require 'cl-lib)
(eval-when-compile
(require 'rx)
(defvar tex-indent-basic)
(defvar tex-indent-item)
(defvar tex-indent-arg)
(defvar evil-shift-width))
(declare-function editorconfig-core-get-properties-hash
"editorconfig-core"
nil)
(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)
(defcustom editorconfig-exec-path
"editorconfig"
"EditorConfig executable name.
This executable is invoked by `editorconfig-call-editorconfig-exec'."
:type 'string
:group 'editorconfig)
(define-obsolete-variable-alias
'edconf-exec-path
'editorconfig-exec-path
"0.5")
(defcustom editorconfig-get-properties-function
'editorconfig-get-properties
"A function which gets EditorConofig properties for current buffer.
This function will be called with no argument and should return a
hash object containing properties, or nil if any core program is
not available. The hash object should have symbols of property
names as keys and strings of property values as values."
:type 'function
:group 'editorconfig)
(define-obsolete-variable-alias
'edconf-get-properties-function
'editorconfig-get-properties-function
"0.5")
(defcustom editorconfig-mode-lighter " EditorConfig"
"Lighter displayed in mode line
when `editorconfig-mode' is enabled."
:type 'string
:group 'editorconfig)
(defcustom editorconfig-custom-hooks ()
"A list of custom hooks 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-custom-hooks
'(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))))))"
:type 'hook
:group 'editorconfig)
(define-obsolete-variable-alias
'edconf-custom-hooks
'editorconfig-custom-hooks
"0.5")
(defcustom editorconfig-indentation-alist
;; For contributors: Sort modes in alphabetical order, please :)
'((apache-mode apache-indent-level)
(awk-mode c-basic-offset)
(c++-mode c-basic-offset)
(c-mode c-basic-offset)
(cmake-mode cmake-tab-width)
(coffee-mode coffee-tab-width)
(cperl-mode cperl-indent-level)
(crystal-mode crystal-indent-level)
(css-mode css-indent-offset)
(emacs-lisp-mode lisp-indent-offset)
(erlang-mode erlang-indent-level)
(ess-mode ess-indent-offset)
(feature-mode feature-indent-offset
feature-indent-level)
(fsharp-mode fsharp-continuation-offset
fsharp-indent-level
fsharp-indent-offset)
(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)
(idl-mode c-basic-offset)
(jade-mode jade-tab-width)
(java-mode c-basic-offset)
(js-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)
(julia-mode julia-indent-offset)
(latex-mode . editorconfig-set-indentation/latex-mode)
(lisp-mode lisp-indent-offset)
(livescript-mode livescript-tab-width)
(lua-mode lua-indent-level)
(matlab-mode matlab-indent-level)
(mustache-mode mustache-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)
(pike-mode c-basic-offset)
(ps-mode ps-mode-tab)
(pug-mode pug-tab-width)
(puppet-mode puppet-indent-level)
(python-mode . editorconfig-set-indentation/python-mode)
(ruby-mode ruby-indent-level)
(rust-mode rust-indent-offset)
(scala-mode scala-indent:step)
(scss-mode css-indent-offset)
(sgml-mode sgml-basic-offset)
(sh-mode sh-basic-offset sh-indentation)
(slim-mode slim-indent-offset)
(tcl-mode tcl-indent-level
tcl-continued-indent-level)
(typescript-mode typescript-indent-level)
(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 (web-mode-indent-style . (lambda (size) 2))
web-mode-attr-indent-offset
web-mode-attr-value-indent-offset
web-mode-code-indent-offset
web-mode-css-indent-offset
web-mode-markup-indent-offset
web-mode-sql-indent-offset
web-mode-block-padding
web-mode-script-padding
web-mode-style-padding)
(yaml-mode yaml-indent-offset))
"Alist of indentation setting methods by modes.
Each element looks like (MODE . FUNCTION) or (MODE . INDENT-SPEC-LIST).
If FUNCTION is provided, it will be called when setting the
indentation. The indent size will be passed.
If INDENT-SPEC-LIST is provided, each element of it must have one of the
following forms:
1. VARIABLE
It means (VARIABLE . 1).
2. (VARIABLE . SPEC)
Setting VARIABLE according to the type of SPEC:
- Integer
The value is (* SPEC INDENT-SIZE);
- Function
The value is (funcall SPEC INDENT-SIZE);
- Any other type.
The value is SPEC.
NOTE: Only the **buffer local** value of VARIABLE will be set."
:type '(alist :key-type symbol :value-type sexp)
:risky t
:group 'editorconfig)
(define-obsolete-variable-alias
'edconf-indentation-alist
'editorconfig-indentation-alist
"0.5")
(defcustom editorconfig-exclude-modes ()
"List of major mode symbols not to apply properties."
:type '(repeat (symbol :tag "Major Mode"))
:group 'editorconfig)
(defcustom editorconfig-exclude-regexps
(list (eval-when-compile
(rx string-start (or "http" "https" "ftp" "sftp" "rsync") ":")))
"List of buffer filename prefix regexp patterns not to apply
properties."
:type '(repeat string)
:group 'editorconfig)
(defvar editorconfig-properties-hash nil
"Hash object of EditorConfig properties 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)
(defun editorconfig-string-integer-p (string)
"Return non-nil if STRING represents integer."
(and (stringp string)
(string-match-p "\\`[0-9]+\\'" string)))
(defun editorconfig-set-indentation/python-mode (size)
"Set `python-mode' indent size to SIZE."
(set (make-local-variable (if (or (> emacs-major-version 24)
(and (= emacs-major-version 24)
(>= emacs-minor-version 3)))
'python-indent-offset
'python-indent))
size)
;; For https://launchpad.net/python-mode
(when (boundp 'py-indent-offset)
(set (make-local-variable 'py-indent-offset) size)))
(defun editorconfig-set-indentation/latex-mode (size)
"Set `latex-mode' indent size to SIZE."
(set (make-local-variable 'tex-indent-basic) size)
(set (make-local-variable 'tex-indent-item) size)
(set (make-local-variable 'tex-indent-arg) (* 2 size))
;; For AUCTeX
(when (boundp 'TeX-brace-indent-level)
(set (make-local-variable 'TeX-brace-indent-level) size))
(when (boundp 'LaTeX-indent-level)
(set (make-local-variable 'LaTeX-indent-level) size))
(when (boundp 'LaTeX-item-indent)
(set (make-local-variable 'LaTeX-item-indent) (- size))))
(defun editorconfig-set-indentation (style &optional size tab_width)
"Set indentation type from STYLE, SIZE and TAB_WIDTH."
(make-local-variable 'indent-tabs-mode)
(make-local-variable 'tab-width)
(if (editorconfig-string-integer-p size)
(setq size (string-to-number size))
(when (not (equal size "tab")) (setq size nil)))
(setq tab-width (cond (tab_width (string-to-number tab_width))
((numberp size) size)
(t tab-width)))
(when (equal size "tab")
(setq size tab-width))
(cond ((equal style "space")
(setq indent-tabs-mode nil))
((equal style "tab")
(setq indent-tabs-mode t)))
(when size
(when (featurep 'evil)
(set (make-local-variable 'evil-shift-width) size))
(let ((parent major-mode)
entry)
;; Find the closet parent mode of `major-mode' in
;; `editorconfig-indentation-alist'.
(while (and (not (setq entry (assoc parent editorconfig-indentation-alist)))
(setq parent (get parent 'derived-mode-parent))))
(when entry
(let ((fn-or-list (cdr entry)))
(cond ((functionp fn-or-list) (funcall fn-or-list size))
((listp fn-or-list)
(dolist (elem fn-or-list)
(cond ((symbolp elem) (set (make-local-variable elem) size))
((consp elem)
(let ((spec (cdr elem)))
(set (make-local-variable (car elem))
(cond ((functionp spec) (funcall spec size))
((integerp spec) (* spec size))
(t spec))))))))))))))
(defun editorconfig-set-coding-system (end-of-line charset)
"Set buffer coding system by 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)
(t 'undecided)))
(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)
((equal charset "utf-16le") 'utf-16le)
(t 'undecided))))
(unless (and (eq eol 'undecided)
(eq cs 'undecided))
(set-buffer-file-coding-system (merge-coding-systems
cs
eol)
nil t))))
(defun editorconfig-set-trailing-nl (final-newline)
"Set up requiring final newline (`require-final-newline' and
`mode-require-final-newline') by FINAL-NEWLINE."
(cond
((equal final-newline "true")
;; keep prefs around how/when the nl is added, if set - otherwise add on save
(set (make-local-variable 'require-final-newline) (or require-final-newline t))
(set (make-local-variable 'mode-require-final-newline) (or mode-require-final-newline t)))
((equal final-newline "false")
;; FIXME: Add functionality for actually REMOVING any trailing newlines here!
;; (rather than just making sure we don't automagically ADD a new one)
(set (make-local-variable 'require-final-newline) nil)
(set (make-local-variable 'mode-require-final-newline) nil))))
(defun editorconfig-set-trailing-ws (trim-trailing-ws)
"Set up trimming of trailing whitespace at end of lines by
TRIM-TRAILING-WS."
(make-local-variable 'write-file-functions) ;; just current buffer
(when (equal trim-trailing-ws "true")
;; when true we push delete-trailing-whitespace (emacs > 21)
;; to write-file-functions
(add-to-list
'write-file-functions
'delete-trailing-whitespace))
(when (equal trim-trailing-ws "false")
;; when false we remove every delete-trailing-whitespace
;; from write-file-functions
(setq
write-file-functions
(delete
'delete-trailing-whitespace
write-file-functions))))
(defun editorconfig-set-line-length (length)
"Set the max line length (`fill-column') to LENGTH."
(when (and (editorconfig-string-integer-p length)
(> (string-to-number length) 0))
(setq fill-column (string-to-number length))))
(defun editorconfig--is-a-mode-p (current want)
"Return non-nil if major mode CURRENT is a major mode WANT."
(or (eq current
want)
(let ((parent (get current 'derived-mode-parent)))
(and parent
(editorconfig--is-a-mode-p parent want)))))
(defun editorconfig-set-major-mode (filetype)
"Set buffer `major-mode' by FILETYPE.
FILETYPE should be s string like `\"ini\"`, if not nil or empty string."
(let ((mode (and filetype
(not (string= filetype
""))
(intern (concat filetype
"-mode")))))
(when (and mode
(not (editorconfig--is-a-mode-p major-mode
mode)))
(if (fboundp mode)
(funcall mode)
(display-warning :error (format "Major-mode `%S' not found"
mode))
nil))))
(defun editorconfig-call-editorconfig-exec ()
"Call EditorConfig core and return output."
(let ((filename (buffer-file-name)))
(with-temp-buffer
(setq default-directory "/")
(if (eq 0
(call-process editorconfig-exec-path nil t nil filename))
(buffer-string)
(error (buffer-string))))))
(defun editorconfig-parse-properties (props-string)
"Create properties hash table from PROPS-STRING."
(let (props-list properties)
(setq props-list (split-string props-string "\n")
properties (make-hash-table :test 'equal))
(dolist (prop props-list properties)
(let ((key-val (split-string prop " *= *")))
(when (> (length key-val) 1)
(let ((key (intern (car key-val)))
(val (mapconcat 'identity (cdr key-val) "")))
(puthash key val properties)))))))
(defun editorconfig-get-properties-from-exec ()
"Get EditorConfig properties of current buffer by calling
`editorconfig-exec-path'."
(if (executable-find editorconfig-exec-path)
(editorconfig-parse-properties (editorconfig-call-editorconfig-exec))
(error "Unable to find editorconfig executable")))
(defun editorconfig-get-properties ()
"Get EditorConfig properties of current buffer.
It calls `editorconfig-get-properties-from-exec' if
`editorconfig-exec-path' is found, otherwise
`editorconfig-core-get-properties-hash'."
(if (and (executable-find editorconfig-exec-path)
(not (file-remote-p buffer-file-name)))
(editorconfig-get-properties-from-exec)
(require 'editorconfig-core)
(editorconfig-core-get-properties-hash)))
;;;###autoload
(defun editorconfig-find-current-editorconfig ()
"Find the closest .editorconfig file for current file."
(interactive)
(eval-and-compile (require 'editorconfig-core))
(let ((file (editorconfig-core-get-nearest-editorconfig
default-directory)))
(when file
(find-file file))))
;;;###autoload
(defun editorconfig-display-current-properties ()
"Display EditorConfig properties extracted for current buffer."
(interactive)
(if editorconfig-properties-hash
(let (
(buf (get-buffer-create "*EditorConfig Properties*"))
(file buffer-file-name)
(props editorconfig-properties-hash))
(with-current-buffer buf
(erase-buffer)
(insert (format "# EditorConfig for %s\n" file))
(maphash (lambda (k v)
(insert (format "%S = %s\n" k v)))
props))
(display-buffer buf))
(message "Properties are not applied to current buffer yet.")
nil))
;;;###autoload
(defun editorconfig-apply ()
"Apply EditorConfig properties for current buffer.
This function ignores `editorconfig-exclude-modes' and always
applies available properties."
(interactive)
(when buffer-file-name
(condition-case err
(progn
(unless (functionp editorconfig-get-properties-function)
(error "Invalid editorconfig-get-properties-function value"))
(let ((props (funcall editorconfig-get-properties-function)))
(progn
(setq editorconfig-properties-hash props)
(editorconfig-set-indentation (gethash 'indent_style props)
(gethash 'indent_size props)
(gethash 'tab_width props))
(editorconfig-set-coding-system
(gethash 'end_of_line props)
(gethash 'charset props))
(editorconfig-set-trailing-nl (gethash 'insert_final_newline props))
(editorconfig-set-trailing-ws (gethash 'trim_trailing_whitespace props))
(editorconfig-set-line-length (gethash 'max_line_length props))
(editorconfig-set-major-mode (gethash 'file_type_emacs props))
(condition-case err
(run-hook-with-args 'editorconfig-custom-hooks props)
(error
(display-warning 'editorconfig-custom-hooks
(concat (error-message-string err)
". Stop running hook.")
:warning))))))
(error
(display-warning 'editorconfig
(concat (error-message-string err)
". Styles will not be applied.")
:error)))))
(defun editorconfig-mode-apply ()
"Apply EditorConfig properties for current buffer.
This function does the job only when the major mode is not listed
in `editorconfig-exclude-modes'."
(when (and major-mode
(not (memq major-mode
editorconfig-exclude-modes))
buffer-file-name
(not (cl-loop for regexp in editorconfig-exclude-regexps
if (string-match regexp buffer-file-name) return t
finally return nil)))
(editorconfig-apply)))
(defun editorconfig-format-buffer()
"Format buffer according to .editorconfig indent_style and indent_width"
(interactive)
(if (string= (gethash 'indent_style editorconfig-properties-hash) "tab")
(tabify (point-min) (point-max)))
(if (string= (gethash 'indent_style editorconfig-properties-hash) "space")
(untabify (point-min) (point-max)))
(indent-region (point-min) (point-max)))
;;;###autoload
(define-minor-mode editorconfig-mode
"Toggle EditorConfig feature.
When enabled EditorConfig properties will be applied to buffers
when first visiting files or changing major modes if the major
mode is not listed in `editorconfig-exclude-modes'."
:global t
:lighter editorconfig-mode-lighter
;; See https://github.com/editorconfig/editorconfig-emacs/issues/141 for why
;; not `after-change-major-mode-hook'
(dolist (hook '(change-major-mode-after-body-hook))
(if editorconfig-mode
(add-hook hook 'editorconfig-mode-apply)
(remove-hook hook 'editorconfig-mode-apply))))
(provide 'editorconfig)
;;; editorconfig.el ends here
;; Local Variables:
;; sentence-end-double-space: t
;; End:

BIN
emacs/.emacs.d/elpa/editorconfig-20171208.2036/editorconfig.elc Normal file
View File

Binary file not shown.