From af5a3bae53fe3a104d9a8cd8e7b83e8a25500701 Mon Sep 17 00:00:00 2001 From: kj Date: Sun, 27 Sep 2020 13:53:49 -0400 Subject: [PATCH] Agregado yaml-mode. --- .../yaml-mode-autoloads.el | 33 ++ elpa/yaml-mode-20200725.1836/yaml-mode-pkg.el | 2 + elpa/yaml-mode-20200725.1836/yaml-mode.el | 488 ++++++++++++++++++ elpa/yaml-mode-20200725.1836/yaml-mode.elc | Bin 0 -> 14317 bytes init.el | 2 +- 5 files changed, 524 insertions(+), 1 deletion(-) create mode 100644 elpa/yaml-mode-20200725.1836/yaml-mode-autoloads.el create mode 100644 elpa/yaml-mode-20200725.1836/yaml-mode-pkg.el create mode 100644 elpa/yaml-mode-20200725.1836/yaml-mode.el create mode 100644 elpa/yaml-mode-20200725.1836/yaml-mode.elc diff --git a/elpa/yaml-mode-20200725.1836/yaml-mode-autoloads.el b/elpa/yaml-mode-20200725.1836/yaml-mode-autoloads.el new file mode 100644 index 0000000..fa9bb77 --- /dev/null +++ b/elpa/yaml-mode-20200725.1836/yaml-mode-autoloads.el @@ -0,0 +1,33 @@ +;;; yaml-mode-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "yaml-mode" "yaml-mode.el" (0 0 0 0)) +;;; Generated autoloads from yaml-mode.el + +(let ((loads (get 'yaml 'custom-loads))) (if (member '"yaml-mode" loads) nil (put 'yaml 'custom-loads (cons '"yaml-mode" loads)))) + +(autoload 'yaml-mode "yaml-mode" "\ +Simple mode to edit YAML. + +\\{yaml-mode-map} + +\(fn)" t nil) + +(add-to-list 'auto-mode-alist '("\\.\\(e?ya?\\|ra\\)ml\\'" . yaml-mode)) + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "yaml-mode" '("yaml-"))) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; yaml-mode-autoloads.el ends here diff --git a/elpa/yaml-mode-20200725.1836/yaml-mode-pkg.el b/elpa/yaml-mode-20200725.1836/yaml-mode-pkg.el new file mode 100644 index 0000000..0617f9c --- /dev/null +++ b/elpa/yaml-mode-20200725.1836/yaml-mode-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "yaml-mode" "20200725.1836" "Major mode for editing YAML files" '((emacs "24.1")) :commit "68fecb5f0dec712a10c8655df6881392a4613617" :keywords '("data" "yaml") :authors '(("Yoshiki Kurihara" . "clouder@gmail.com") ("Marshall T. Vandegrift" . "llasram@gmail.com")) :maintainer '("Vasilij Schneidermann" . "mail@vasilij.de")) diff --git a/elpa/yaml-mode-20200725.1836/yaml-mode.el b/elpa/yaml-mode-20200725.1836/yaml-mode.el new file mode 100644 index 0000000..2c95da0 --- /dev/null +++ b/elpa/yaml-mode-20200725.1836/yaml-mode.el @@ -0,0 +1,488 @@ +;;; yaml-mode.el --- Major mode for editing YAML files + +;; Copyright (C) 2010-2014 Yoshiki Kurihara + +;; Author: Yoshiki Kurihara +;; Marshall T. Vandegrift +;; Maintainer: Vasilij Schneidermann +;; Package-Requires: ((emacs "24.1")) +;; Package-Version: 20200725.1836 +;; Package-Commit: 68fecb5f0dec712a10c8655df6881392a4613617 +;; Keywords: data yaml +;; Version: 0.0.14 + +;; This file is not part of Emacs + +;; This file 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 2, or (at your option) +;; any later version. + +;; This file 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 this program; if not, write to the Free Software Foundation, Inc., +;; 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +;;; Commentary: + +;; This is a major mode for editing files in the YAML data +;; serialization format. It was initially developed by Yoshiki +;; Kurihara and many features were added by Marshall Vandegrift. As +;; YAML and Python share the fact that indentation determines +;; structure, this mode provides indentation and indentation command +;; behavior very similar to that of python-mode. + +;;; Installation: + +;; To install, just drop this file into a directory in your +;; `load-path' and (optionally) byte-compile it. To automatically +;; handle files ending in '.yml', add something like: +;; +;; (require 'yaml-mode) +;; (add-to-list 'auto-mode-alist '("\\.yml\\'" . yaml-mode)) +;; +;; to your .emacs file. +;; +;; Unlike python-mode, this mode follows the Emacs convention of not +;; binding the ENTER key to `newline-and-indent'. To get this +;; behavior, add the key definition to `yaml-mode-hook': +;; +;; (add-hook 'yaml-mode-hook +;; '(lambda () +;; (define-key yaml-mode-map "\C-m" 'newline-and-indent))) + +;;; Known Bugs: + +;; YAML is easy to write but complex to parse, and this mode doesn't +;; even really try. Indentation and highlighting will break on +;; abnormally complicated structures. + +;;; Code: + + +;; User definable variables + +;;;###autoload +(defgroup yaml nil + "Support for the YAML serialization format" + :group 'languages + :prefix "yaml-") + +(defcustom yaml-mode-hook nil + "*Hook run by `yaml-mode'." + :type 'hook + :group 'yaml) + +(defcustom yaml-indent-offset 2 + "*Amount of offset per level of indentation." + :type 'integer + :safe 'natnump + :group 'yaml) + +(defcustom yaml-backspace-function 'backward-delete-char-untabify + "*Function called by `yaml-electric-backspace' when deleting backwards. +It will receive one argument, the numeric prefix value." + :type 'function + :group 'yaml) + +(defcustom yaml-block-literal-search-lines 100 + "*Maximum number of lines to search for start of block literals." + :type 'integer + :group 'yaml) + +(defcustom yaml-block-literal-electric-alist + '((?| . "") (?> . "-")) + "*Characters for which to provide electric behavior. +The association list key should be a key code and the associated value +should be a string containing additional characters to insert when +that key is pressed to begin a block literal." + :type 'alist + :group 'yaml) + +(defface yaml-tab-face + '((((class color)) (:background "red" :foreground "red" :bold t)) + (t (:reverse-video t))) + "Face to use for highlighting tabs in YAML files." + :group 'faces + :group 'yaml) + +(defcustom yaml-imenu-generic-expression + '((nil "^\\(:?[a-zA-Z_-]+\\):" 1)) + "The imenu regex to parse an outline of the yaml file." + :type 'string + :group 'yaml) + + +;; Constants + +(defconst yaml-mode-version "0.0.14" "Version of `yaml-mode'.") + +(defconst yaml-blank-line-re "^ *$" + "Regexp matching a line containing only (valid) whitespace.") + +(defconst yaml-directive-re "^\\(?:--- \\)? *%\\(\\w+\\)" + "Regexp matching a line contatining a YAML directive.") + +(defconst yaml-document-delimiter-re "^\\(?:---\\|[.][.][.]\\)" + "Rexexp matching a YAML document delimiter line.") + +(defconst yaml-node-anchor-alias-re "[&*][a-zA-Z0-9_-]+" + "Regexp matching a YAML node anchor or alias.") + +(defconst yaml-tag-re "!!?[^ \n]+" + "Rexexp matching a YAML tag.") + +(defconst yaml-bare-scalar-re + "\\(?:[^-:,#!\n{\\[ ]\\|[^#!\n{\\[ ]\\S-\\)[^#\n]*?" + "Rexexp matching a YAML bare scalar.") + +(defconst yaml-hash-key-re + (concat "\\(?:^\\(?:--- \\)?\\|{\\|\\(?:[-,] +\\)+\\) *" + "\\(?:" yaml-tag-re " +\\)?" + "\\(" yaml-bare-scalar-re "\\) *:" + "\\(?: +\\|$\\)") + "Regexp matching a single YAML hash key.") + +(defconst yaml-scalar-context-re + (concat "\\(?:^\\(?:--- \\)?\\|{\\|\\(?: *[-,] +\\)+\\) *" + "\\(?:" yaml-bare-scalar-re " *: \\)?") + "Regexp indicating the beginning of a scalar context.") + +(defconst yaml-nested-map-re + (concat "[^#\n]*: *\\(?:&.*\\|{ *\\|" yaml-tag-re " *\\)?$") + "Regexp matching a line beginning a YAML nested structure.") + +(defconst yaml-block-literal-base-re " *[>|][-+0-9]* *\\(?:\n\\|\\'\\)" + "Regexp matching the substring start of a block literal.") + +(defconst yaml-block-literal-re + (concat yaml-scalar-context-re + "\\(?:" yaml-tag-re "\\)?" + yaml-block-literal-base-re) + "Regexp matching a line beginning a YAML block literal.") + +(defconst yaml-nested-sequence-re + (concat "^\\(?:\\(?: *- +\\)+\\|\\(:? *-$\\)\\)" + "\\(?:" yaml-bare-scalar-re " *:\\(?: +.*\\)?\\)?$") + "Regexp matching a line containing one or more nested YAML sequences.") + +(defconst yaml-constant-scalars-re + (concat "\\(?:^\\|\\(?::\\|-\\|,\\|{\\|\\[\\) +\\) *" + (regexp-opt + '("~" "null" "Null" "NULL" + ".nan" ".NaN" ".NAN" + ".inf" ".Inf" ".INF" + "-.inf" "-.Inf" "-.INF" + "y" "Y" "yes" "Yes" "YES" "n" "N" "no" "No" "NO" + "true" "True" "TRUE" "false" "False" "FALSE" + "on" "On" "ON" "off" "Off" "OFF") t) + " *$") + "Regexp matching certain scalar constants in scalar context.") + + +;; Mode setup + +(defvar yaml-mode-map + (let ((map (make-sparse-keymap))) + (define-key map "|" 'yaml-electric-bar-and-angle) + (define-key map ">" 'yaml-electric-bar-and-angle) + (define-key map "-" 'yaml-electric-dash-and-dot) + (define-key map "." 'yaml-electric-dash-and-dot) + (define-key map (kbd "DEL") 'yaml-electric-backspace) + map) + "Keymap used in `yaml-mode' buffers.") + +(defvar yaml-mode-syntax-table + (let ((syntax-table (make-syntax-table))) + (modify-syntax-entry ?\' "\"" syntax-table) + (modify-syntax-entry ?\" "\"" syntax-table) + (modify-syntax-entry ?# "<" syntax-table) + (modify-syntax-entry ?\n ">" syntax-table) + (modify-syntax-entry ?\\ "\\" syntax-table) + (modify-syntax-entry ?- "_" syntax-table) + (modify-syntax-entry ?_ "_" syntax-table) + (modify-syntax-entry ?& "." syntax-table) + (modify-syntax-entry ?* "." syntax-table) + (modify-syntax-entry ?\( "." syntax-table) + (modify-syntax-entry ?\) "." syntax-table) + (modify-syntax-entry ?\{ "(}" syntax-table) + (modify-syntax-entry ?\} "){" syntax-table) + (modify-syntax-entry ?\[ "(]" syntax-table) + (modify-syntax-entry ?\] ")[" syntax-table) + syntax-table) + "Syntax table in use in `yaml-mode' buffers.") + +;;;###autoload +(define-derived-mode yaml-mode text-mode "YAML" + "Simple mode to edit YAML. + +\\{yaml-mode-map}" + :syntax-table yaml-mode-syntax-table + (set (make-local-variable 'comment-start) "# ") + (set (make-local-variable 'comment-start-skip) "#+ *") + (set (make-local-variable 'indent-line-function) 'yaml-indent-line) + (set (make-local-variable 'indent-tabs-mode) nil) + (set (make-local-variable 'fill-paragraph-function) 'yaml-fill-paragraph) + + (set (make-local-variable 'syntax-propertize-function) + 'yaml-mode-syntax-propertize-function) + (setq font-lock-defaults '(yaml-font-lock-keywords))) + + +;; Font-lock support + +(defvar yaml-font-lock-keywords + `((yaml-font-lock-block-literals 0 font-lock-string-face) + (,yaml-constant-scalars-re . (1 font-lock-constant-face)) + (,yaml-tag-re . (0 font-lock-type-face)) + (,yaml-node-anchor-alias-re . (0 font-lock-function-name-face)) + (,yaml-hash-key-re . (1 font-lock-variable-name-face)) + (,yaml-document-delimiter-re . (0 font-lock-comment-face)) + (,yaml-directive-re . (1 font-lock-builtin-face)) + ("^[\t]+" 0 'yaml-tab-face t)) + "Additional expressions to highlight in YAML mode.") + +(defun yaml-mode-syntax-propertize-function (beg end) + "Override buffer's syntax table for special syntactic constructs." + ;; Unhighlight foo#bar tokens between BEG and END. + (save-excursion + (goto-char beg) + (while (search-forward "#" end t) + (save-excursion + (forward-char -1) + ;; both ^# and [ \t]# are comments + (when (and (not (bolp)) + (not (memq (preceding-char) '(?\s ?\t)))) + (put-text-property (point) (1+ (point)) + 'syntax-table (string-to-syntax "_")))))) + + (save-excursion + (goto-char beg) + (while (and + (> end (point)) + (re-search-forward "['\"]" end t)) + (when (get-text-property (point) 'yaml-block-literal) + (put-text-property (1- (point)) (point) + 'syntax-table (string-to-syntax "w"))) + (let* ((pt (point)) + (sps (save-excursion (syntax-ppss (1- pt))))) + (when (not (nth 8 sps)) + (cond + ((and (char-equal ?' (char-before (1- pt))) + (char-equal ?' (char-before pt))) + (put-text-property (- pt 2) pt + 'syntax-table (string-to-syntax "w")) + ;; Workaround for https://debbugs.gnu.org/41195. + (let ((syntax-propertize--done syntax-propertize--done)) + ;; Carefully invalidate the last cached ppss. + (syntax-ppss-flush-cache (- pt 2)))) + ;; If quote is detected as a syntactic string start but appeared + ;; after a non-whitespace character, then mark it as syntactic word. + ((and (char-before (1- pt)) + (char-equal ?w (char-syntax (char-before (1- pt))))) + (put-text-property (1- pt) pt + 'syntax-table (string-to-syntax "w"))) + (t + ;; We're right after a quote that opens a string literal. + ;; Skip over it (big speedup for long JSON strings). + (goto-char (1- pt)) + (condition-case nil + (forward-sexp) + (scan-error + (goto-char end)))))))))) + +(defun yaml-font-lock-block-literals (bound) + "Find lines within block literals. +Find the next line of the first (if any) block literal after point and +prior to BOUND. Returns the beginning and end of the block literal +line in the match data, as consumed by `font-lock-keywords' matcher +functions. The function begins by searching backwards to determine +whether or not the current line is within a block literal. This could +be time-consuming in large buffers, so the number of lines searched is +artificially limited to the value of +`yaml-block-literal-search-lines'." + (if (eolp) (goto-char (1+ (point)))) + (unless (or (eobp) (>= (point) bound)) + (let ((begin (point)) + (end (min (1+ (point-at-eol)) bound))) + (goto-char (point-at-bol)) + (while (and (looking-at yaml-blank-line-re) + (not (bobp))) + (forward-line -1)) + (let ((nlines yaml-block-literal-search-lines) + (min-level (current-indentation))) + (forward-line -1) + (while (and (/= nlines 0) + (/= min-level 0) + (not (looking-at yaml-block-literal-re)) + (not (bobp))) + (setq nlines (1- nlines)) + (unless (looking-at yaml-blank-line-re) + (setq min-level (min min-level (current-indentation)))) + (forward-line -1)) + (cond + ((and (< (current-indentation) min-level) + (looking-at yaml-block-literal-re)) + (goto-char end) + (put-text-property begin end 'yaml-block-literal t) + (set-match-data (list begin end)) + t) + ((progn + (goto-char begin) + (re-search-forward (concat yaml-block-literal-re + " *\\(.*\\)\n") + bound t)) + (let ((range (nthcdr 2 (match-data)))) + (put-text-property (car range) (cadr range) 'yaml-block-literal t) + (set-match-data range)) + t)))))) + + +;; Indentation and electric keys + +(defun yaml-compute-indentation () + "Calculate the maximum sensible indentation for the current line." + (save-excursion + (beginning-of-line) + (if (looking-at yaml-document-delimiter-re) 0 + (forward-line -1) + (while (and (looking-at yaml-blank-line-re) + (> (point) (point-min))) + (forward-line -1)) + (+ (current-indentation) + (if (looking-at yaml-nested-map-re) yaml-indent-offset 0) + (if (looking-at yaml-nested-sequence-re) yaml-indent-offset 0) + (if (looking-at yaml-block-literal-re) yaml-indent-offset 0))))) + +(defun yaml-indent-line () + "Indent the current line. +The first time this command is used, the line will be indented to the +maximum sensible indentation. Each immediately subsequent usage will +back-dent the line by `yaml-indent-offset' spaces. On reaching column +0, it will cycle back to the maximum sensible indentation." + (interactive "*") + (let ((ci (current-indentation)) + (cc (current-column)) + (need (yaml-compute-indentation))) + (save-excursion + (beginning-of-line) + (delete-horizontal-space) + (if (and (equal last-command this-command) (/= ci 0)) + (indent-to (* (/ (- ci 1) yaml-indent-offset) yaml-indent-offset)) + (indent-to need))) + (if (< (current-column) (current-indentation)) + (forward-to-indentation 0)))) + +(defun yaml-electric-backspace (arg) + "Delete characters or back-dent the current line. +If invoked following only whitespace on a line, will back-dent to the +immediately previous multiple of `yaml-indent-offset' spaces." + (interactive "*p") + (if (or (/= (current-indentation) (current-column)) (bolp)) + (funcall yaml-backspace-function arg) + (let ((ci (current-column))) + (beginning-of-line) + (delete-horizontal-space) + (indent-to (* (/ (- ci (* arg yaml-indent-offset)) + yaml-indent-offset) + yaml-indent-offset))))) + +(defun yaml-electric-bar-and-angle (arg) + "Insert the bound key and possibly begin a block literal. +Inserts the bound key. If inserting the bound key causes the current +line to match the initial line of a block literal, then inserts the +matching string from `yaml-block-literal-electric-alist', a newline, +and indents appropriately." + (interactive "*P") + (self-insert-command (prefix-numeric-value arg)) + (let ((extra-chars + (assoc last-command-event + yaml-block-literal-electric-alist))) + (cond + ((and extra-chars (not arg) (eolp) + (save-excursion + (beginning-of-line) + (looking-at yaml-block-literal-re))) + (insert (cdr extra-chars)) + (newline-and-indent))))) + +(defun yaml-electric-dash-and-dot (arg) + "Insert the bound key and possibly de-dent line. +Inserts the bound key. If inserting the bound key causes the current +line to match a document delimiter, de-dent the line to the left +margin." + (interactive "*P") + (self-insert-command (prefix-numeric-value arg)) + (save-excursion + (beginning-of-line) + (when (and (not arg) (looking-at yaml-document-delimiter-re)) + (delete-horizontal-space)))) + +(defun yaml-narrow-to-block-literal () + "Narrow the buffer to block literal if the point is in it, +otherwise do nothing." + (interactive) + (save-excursion + (goto-char (point-at-bol)) + (while (and (looking-at-p yaml-blank-line-re) (not (bobp))) + (forward-line -1)) + (let ((nlines yaml-block-literal-search-lines) + (min-level (current-indentation)) + beg) + (forward-line -1) + (while (and (/= nlines 0) + (/= min-level 0) + (not (looking-at-p yaml-block-literal-re)) + (not (bobp))) + (setq nlines (1- nlines)) + (unless (looking-at-p yaml-blank-line-re) + (setq min-level (min min-level (current-indentation)))) + (forward-line -1)) + (when (and (< (current-indentation) min-level) + (looking-at-p yaml-block-literal-re)) + (setq min-level (current-indentation)) + (forward-line) + (setq beg (point)) + (while (and (not (eobp)) + (or (looking-at-p yaml-blank-line-re) + (> (current-indentation) min-level))) + (forward-line)) + (narrow-to-region beg (point)))))) + +(defun yaml-fill-paragraph (&optional justify region) + "Fill paragraph. +Outside of comments, this behaves as `fill-paragraph' except that +filling does not cross boundaries of block literals. Inside comments, +this will do usual adaptive fill behaviors." + (interactive "*P") + (save-restriction + (yaml-narrow-to-block-literal) + (let ((fill-paragraph-function nil)) + (or (fill-comment-paragraph justify) + (fill-paragraph justify region))))) + +(defun yaml-set-imenu-generic-expression () + (make-local-variable 'imenu-generic-expression) + (make-local-variable 'imenu-create-index-function) + (setq imenu-create-index-function 'imenu-default-create-index-function) + (setq imenu-generic-expression yaml-imenu-generic-expression)) + +(add-hook 'yaml-mode-hook 'yaml-set-imenu-generic-expression) + + +(defun yaml-mode-version () + "Display version of `yaml-mode'." + (interactive) + (message "yaml-mode %s" yaml-mode-version) + yaml-mode-version) + +;;;###autoload +(add-to-list 'auto-mode-alist '("\\.\\(e?ya?\\|ra\\)ml\\'" . yaml-mode)) + +(provide 'yaml-mode) + +;;; yaml-mode.el ends here diff --git a/elpa/yaml-mode-20200725.1836/yaml-mode.elc b/elpa/yaml-mode-20200725.1836/yaml-mode.elc new file mode 100644 index 0000000000000000000000000000000000000000..12b7cdb06862f6c0eea94d1c0fa31cff234dc7fe GIT binary patch literal 14317 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 IOKa8t7vNrjSpWb4 literal 0 HcmV?d00001 diff --git a/init.el b/init.el index 326b189..9353334 100644 --- a/init.el +++ b/init.el @@ -51,7 +51,7 @@ '(magit-diff-use-overlays nil) '(package-selected-packages (quote - (smooth-scrolling web-mode multi-web-mode spacemacs-theme flycheck ac-emmet markdown-preview-mode multiple-cursors git-gutter powerline ample-zen-theme monokai-theme dracula-theme auto-complete neotree all-the-icons spinner markdown-mode lv ht f evil dash-functional))) + (yaml-mode smooth-scrolling web-mode multi-web-mode spacemacs-theme flycheck ac-emmet markdown-preview-mode multiple-cursors git-gutter powerline ample-zen-theme monokai-theme dracula-theme auto-complete neotree all-the-icons spinner markdown-mode lv ht f evil dash-functional))) '(pdf-view-midnight-colors (quote ("#b2b2b2" . "#292b2e"))) '(pos-tip-background-color "#FFFACE") '(pos-tip-foreground-color "#272822")