From ee71e659df3fe8673c3facc2a31ca05785bc9519 Mon Sep 17 00:00:00 2001 From: Marcus Kammer <2262664-marcus-kammer@users.noreply.gitlab.com> Date: Tue, 18 Feb 2020 14:00:43 +0100 Subject: [PATCH] Activate Plantuml and dot --- .org-id-locations | 2 + bundle/custom.el | 2 +- bundle/org-mode-settings.el | 6 +- elpa/archives/gnu/archive-contents | 2 +- .../dot-mode-autoloads.el | 76 ++ elpa/dot-mode-20180312.2300/dot-mode-pkg.el | 2 + elpa/dot-mode-20180312.2300/dot-mode.el | 514 ++++++++++++ elpa/dot-mode-20180312.2300/dot-mode.elc | Bin 0 -> 11248 bytes .../plantuml-mode-autoloads.el | 32 + .../plantuml-mode-pkg.el | 2 + .../plantuml-mode.el | 762 ++++++++++++++++++ .../plantuml-mode.elc | Bin 0 -> 30921 bytes 12 files changed, 1397 insertions(+), 3 deletions(-) create mode 100644 .org-id-locations create mode 100644 elpa/dot-mode-20180312.2300/dot-mode-autoloads.el create mode 100644 elpa/dot-mode-20180312.2300/dot-mode-pkg.el create mode 100644 elpa/dot-mode-20180312.2300/dot-mode.el create mode 100644 elpa/dot-mode-20180312.2300/dot-mode.elc create mode 100644 elpa/plantuml-mode-20191102.2056/plantuml-mode-autoloads.el create mode 100644 elpa/plantuml-mode-20191102.2056/plantuml-mode-pkg.el create mode 100644 elpa/plantuml-mode-20191102.2056/plantuml-mode.el create mode 100644 elpa/plantuml-mode-20191102.2056/plantuml-mode.elc diff --git a/.org-id-locations b/.org-id-locations new file mode 100644 index 00000000..cc259c42 --- /dev/null +++ b/.org-id-locations @@ -0,0 +1,2 @@ + +nil diff --git a/bundle/custom.el b/bundle/custom.el index 4b8a9d57..f74d536a 100644 --- a/bundle/custom.el +++ b/bundle/custom.el @@ -65,7 +65,7 @@ '(package-enable-at-startup t) '(package-selected-packages (quote - (elisp-format elisp-lint flymake-racket google-translate org-pomodoro olivetti elm-mode dashboard pickle poet-theme flymake-eslint json-mode elpy darkroom dockerfile-mode ein spacemacs-theme flucui-themes leuven-theme htmlize scss-mode berrys-theme web-mode python-docstring sphinx-doc sphinx-frontend sphinx-mode ox-nikola racket-mode slime gherkin-mode powershell typescript-mode ob-http ob-ipython ob-restclient nord-theme restclient request restclient-test yaml-mode magit))) + (dot-mode plantuml-mode elisp-format elisp-lint flymake-racket google-translate org-pomodoro olivetti elm-mode dashboard pickle poet-theme flymake-eslint json-mode elpy darkroom dockerfile-mode ein spacemacs-theme flucui-themes leuven-theme htmlize scss-mode berrys-theme web-mode python-docstring sphinx-doc sphinx-frontend sphinx-mode ox-nikola racket-mode slime gherkin-mode powershell typescript-mode ob-http ob-ipython ob-restclient nord-theme restclient request restclient-test yaml-mode magit))) '(python-shell-interpreter "python3") '(register-preview-delay 2) '(register-separator 43) diff --git a/bundle/org-mode-settings.el b/bundle/org-mode-settings.el index fb869612..1bac1f84 100644 --- a/bundle/org-mode-settings.el +++ b/bundle/org-mode-settings.el @@ -10,7 +10,9 @@ (lisp . t) (shell . t) (css . t) - (calc . t))) + (calc . t) + (plantuml . t) + (dot . t))) org-babel-shell-names (quote ("sh" "bash" "csh" "ash" "dash" "ksh" "mksh" "posh")) org-clock-persist t org-confirm-babel-evaluate nil @@ -31,6 +33,8 @@ (when (string= (system-name) "EVG02667NB") (setq org-duration-format (quote h:mm) org-babel-python-command "python") + (setq org-plantuml-jar-path + (expand-file-name "~/AppData/Local/Programs/plantuml/plantuml.jar")) (when *docs-path* (setq org-agenda-files `(,(concat *docs-path* "\\Journal")) org-default-notes-file (concat *docs-path* "\\Journal\\notes.org")))) diff --git a/elpa/archives/gnu/archive-contents b/elpa/archives/gnu/archive-contents index 5ee60f4e..f8abda2e 100644 --- a/elpa/archives/gnu/archive-contents +++ b/elpa/archives/gnu/archive-contents @@ -397,7 +397,7 @@ ("Gary D. Foster" . "Gary.Foster@Corp.Sun.COM")) (:maintainer "Luke Lee" . "luke.yx.lee@gmail.com"))]) (csv-mode . - [(1 11) + [(1 12) ((emacs (24 1)) (cl-lib diff --git a/elpa/dot-mode-20180312.2300/dot-mode-autoloads.el b/elpa/dot-mode-20180312.2300/dot-mode-autoloads.el new file mode 100644 index 00000000..67496b40 --- /dev/null +++ b/elpa/dot-mode-20180312.2300/dot-mode-autoloads.el @@ -0,0 +1,76 @@ +;;; dot-mode-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "dot-mode" "dot-mode.el" (0 0 0 0)) +;;; Generated autoloads from dot-mode.el + +(autoload 'dot-mode-copy-to-last-kbd-macro "dot-mode" "\ +Copy the current `dot-mode' command buffer to the `last-kbd-macro' variable. +Then it can be called with `call-last-kbd-macro', named with +`name-last-kbd-macro', or even saved for later use with +`name-last-kbd-macro' + +\(fn)" t nil) + +(autoload 'dot-mode-execute "dot-mode" "\ +Execute stored commands. + +\(fn)" t nil) + +(autoload 'dot-mode-override "dot-mode" "\ +Unconditionally store next keystroke. + +\(fn)" t nil) + +(autoload 'dot-mode "dot-mode" "\ +Dot mode mimics the `.' function in vi, repeating sequences of +commands and/or typing delimited by motion events. Use `C-.' +rather than just `.'. + +\(fn &optional ARG)" t nil) + +(autoload 'dot-mode-on "dot-mode" "\ +Turn on dot-mode. + +\(fn)" t nil) + +(defalias 'turn-on-dot-mode 'dot-mode-on) + +(defvar global-dot-mode nil "\ +Non-nil if Global Dot mode is enabled. +See the `global-dot-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 `global-dot-mode'.") + +(custom-autoload 'global-dot-mode "dot-mode" nil) + +(autoload 'global-dot-mode "dot-mode" "\ +Toggle Dot mode in all buffers. +With prefix ARG, enable Global Dot mode if ARG is positive; +otherwise, disable it. If called from Lisp, enable the mode if +ARG is omitted or nil. + +Dot mode is enabled in all buffers where +`dot-mode-on' would do it. +See `dot-mode' for more information on Dot mode. + +\(fn &optional ARG)" t nil) + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "dot-mode" '("dot-mode-"))) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; dot-mode-autoloads.el ends here diff --git a/elpa/dot-mode-20180312.2300/dot-mode-pkg.el b/elpa/dot-mode-20180312.2300/dot-mode-pkg.el new file mode 100644 index 00000000..e67fb08c --- /dev/null +++ b/elpa/dot-mode-20180312.2300/dot-mode-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "dot-mode" "20180312.2300" "minor mode to repeat typing or commands" '((emacs "24.3")) :commit "6ca22b73bcdae2363ee9641b822a60685df16a3e" :keywords '("convenience") :authors '(("Robert Wyrick" . "rob@wyrick.org")) :maintainer '("Robert Wyrick" . "rob@wyrick.org") :url "https://github.com/wyrickre/dot-mode") diff --git a/elpa/dot-mode-20180312.2300/dot-mode.el b/elpa/dot-mode-20180312.2300/dot-mode.el new file mode 100644 index 00000000..31d44a66 --- /dev/null +++ b/elpa/dot-mode-20180312.2300/dot-mode.el @@ -0,0 +1,514 @@ +;;; dot-mode.el --- minor mode to repeat typing or commands + +;;; Copyright (C) 1995 James Gillespie +;;; Copyright (C) 2000 Robert Wyrick (rob@wyrick.org) + +;; Author: Robert Wyrick +;; Maintainer: Robert Wyrick +;; Keywords: convenience +;; Package-Version: 20180312.2300 +;; Version: 1.13 +;; URL: https://github.com/wyrickre/dot-mode +;; Package-Requires: ((emacs "24.3")) + +;;; This program 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 1, or (at your option) +;;; any later version. + +;;; This program 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. + +;;; A copy of the GNU General Public License can be obtained from +;;; the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA +;;; 02139, USA. + +;;; Commentary: + +;; +;; Purpose of this package: minor mode to repeat typing or commands +;; +;; Installation instructions +;; +;; Install this file somewhere in your load path, byte-compile it and +;; add one of the following to your .emacs file (remove the comment +;; delimiters ;-) +;; +;; If you only want dot-mode to activate when you press "C-.", add the +;; the following to your .emacs: +;; +;; (autoload 'dot-mode "dot-mode" nil t) ; vi `.' command emulation +;; (global-set-key [(control ?.)] (lambda () (interactive) (dot-mode 1) +;; (message "Dot mode activated."))) +;; +;; If you want dot-mode all the time (like me), add the following to +;; your .emacs: +;; +;; (require 'dot-mode) +;; (add-hook 'find-file-hooks 'dot-mode-on) +;; +;; You may still want to use the global-set-key above.. especially if you +;; use the *scratch* buffer. +;; +;; To toggle dot mode on or off type `M-x dot-mode' +;; +;; There are only two variables that allow you to modify how dot-mode +;; behaves: +;; dot-mode-ignore-undo +;; dot-mode-global-mode +;; +;; dot-mode-ignore-undo - defaults to t. When nil, it will record keystrokes +;; that generate an undo just like any other keystroke that changed the +;; buffer. I personally find that annoying, but if you want dot-mode to +;; always remember your undo's: +;; (setq dot-mode-ignore-undo nil) +;; Besides, you can always use dot-mode-override to record an undo when +;; you need to (or even M-x undo). +;; +;; dot-mode-global-mode - defaults to t. When t, dot-mode only has one +;; keyboard command buffer. That means you can make a change in one +;; buffer, switch buffers, then repeat the change. When set to nil, +;; each buffer gets its own command buffer. That means that after +;; making a change in a buffer, if you switch buffers, that change +;; cannot repeated. If you switch back to the first buffer, your +;; change can then be repeated again. This has a nasty side effect +;; if your change yanks from the kill-ring (You could end up +;; yanking text you killed in a different buffer). +;; If you want to set this to nil, you should do so before dot-mode +;; is activated on any buffers. Otherwise, you may end up with some +;; buffers having a local command buffer and others using the global +;; one. +;; +;; Usage instructions: +;; +;; `C-.' is bound to dot-mode-execute, which executes the buffer of +;; stored commands as a keyboard macro. +;; +;; `C-M-.' is bound to dot-mode-override, which will cause dot-mode +;; to remember the next keystroke regardless of whether it +;; changes the buffer and regardless of the value of the +;; dot-mode-ignore-undo variable. +;; +;; `C-c-.' is bound to dot-mode-copy-to-last-kbd-macro, which will +;; copy the current dot mode keyboard macro to the last-kbd-macro +;; variable. It can then be executed via call-last-kbd-macro +;; (normally bound to `C-x-e'), named via name-last-kbd-macro, +;; and then inserted into your .emacs via insert-kbd-macro. +;; +;; Known bugs: +;; +;; none +;; + +;;; COMMENTARY +;;; +;;; This mode is written to address one argument in the emacs vs. vi +;;; jihad :-) It emulates the vi `redo' command, repeating the +;;; immediately preceding sequence of commands. This is done by +;;; recording input commands which change the buffer, i.e. not motion +;;; commands. + +;;; DESIGN +;;; +;;; The heart of this minor mode is a state machine. The function +;;; dot-mode-after-change is called from after-change-functions and +;;; sets a variable (is there one already? I couldn't find it) which +;;; is examined by dot-mode-loop, called from from post-command-hook. +;;; This variable, dot-mode-changed, is used in conjunction with +;;; dot-mode-state to move to the next state in the state machine. +;;; The state machine is hard coded into dot-mode-loop in the +;;; interests of speed; it uses two normal states (idle and store) +;;; and two corresponding override states which allow the user to +;;; forcibly store commands which do not change the buffer. +;;; +;;; TODO +;;; * Explore using recent-keys for this functionality + +;;; Code: + +(defconst dot-mode-version "1.13" + "Report bugs to: Robert Wyrick ") + +;;; CHANGE HISTORY +;;; +;;; 1.1 +;;; Wrote dot-mode.el +;;; +;;; 1.2 +;;; At the suggestion of Scott Evans , added +;;; 'dot-mode-override' to allow the user to force dot mode to store a +;;; motion command +;;; +;;; 1.3 +;;; Changed dot-mode-loop to use a state machine instead of several +;;; booleans +;;; +;;; 1.4 +;;; Hard coded the state machine into dot-mode-loop in the hope of +;;; speeding it up +;;; +;;; 1.5 +;;; Ported to GNU Emacs - nearly: the keymap doesn't seem to install +;;; correctly. +;;; +;;; 1.6 +;;; Rob Wyrick (that's me) took over maintenance of the package from +;;; Jim Gillespie. +;;; +;;; In some versions of Emacs, (this-command-keys) returns a empty +;;; vector by the time it is called from the 'post-command-hook. +;;; So, I split the functionality... now dot-mode-command-keys +;;; stores (this-command-keys) output in a temp variable to be used +;;; by dot-mode-loop and dot-mode-command-keys is called from the +;;; pre-command-hook. Also re/ported to XEmacs/GNU Emacs. It works +;;; on both now. dot-mode-command-keys could have been put on the +;;; after-change-functions hook, but I've begun preliminary work to +;;; capture what's going on in the minibuffer and I'm certain I need +;;; it where it is. +;;; +;;; 1.7 +;;; Added my first attempt to capture what the user is doing with +;;; execute-extended-command (M-x). It even works if the executed +;;; command prompts the user. +;;; Also added some error recovery if the user interrupts or there is +;;; an error during execution of the stored macro. +;;; +;;; 1.8 +;;; Second attempt to capture what the user is doing with +;;; execute-extended-command (M-x). The previous version didn't work +;;; in XEmacs. This version works in both XEmacs and GNUEmacs. +;;; +;;; 1.9 +;;; Third attempt to capture what the user is doing with +;;; execute-extended-command (M-x). Wow was I making things hard. +;;; It's cost me a lot of version numbers in a short amount of time, +;;; so we won't discuss my previous attempts. *grin* My second attempt +;;; worked just fine, but it was more complicated and maybe not as +;;; portable to older version of X/GNU Emacs. +;;; Other things: +;;; - Yet another restructuring of the code. By doing so, +;;; quoted-insert (C-q) is properly stored by dot-mode. +;;; (quoted-insert has been broken since ver 1.6) +;;; - Deleted an extraneous state and the "extended-state" added +;;; in ver 1.8. We're down to just two normal states and two +;;; override states. +;;; - Added dot-mode-ignore-undo and dot-mode-global-mode variables +;;; as well as the new function dot-mode-copy-to-last-kbd-macro. +;;; +;;; 1.10 +;;; Fixed a bug where the META key wasn't properly recorded on GNU +;;; Emacs. Actually, if you used ESC for META (like me), everything +;;; worked fine. But using ALT for META was broken. +;;; Now I'm using this-command-keys-vector when I can. +;;; I also added the dot-mode-event-to-string function to make the +;;; output a little prettier. +;;; Thanks to Scott Evans for reporting the bug! +;;; +;;; 1.11 +;;; Fixed a bug where dot-mode would give an error if you used +;;; dot-mode-override to record a and then tried to call +;;; dot-mode-execute. The bug was in dot-mode-event-to-string +;;; Thanks to Scott Evans for reporting the bug! +;;; +;;; 1.12 +;;; Make calls to make-local-hook optional for Emacs 24 compatibility. +;;; Use kmacro-display for displaying the macro string. +;;; +;;; 1.13 +;;; Misc updates to follow elisp progression and add tests. +;;; Remove XEmacs compatibility. + +(require 'kmacro) + +(defvar dot-mode-global-mode t + "Should dot-mode share its command buffer between buffers?") + +(defvar dot-mode-ignore-undo t + "Should dot-mode ignore undo?") + +(defvar dot-mode-changed nil + "Did last command change buffer?") + +(defvar dot-mode-cmd-buffer nil + "Saved commands.") + +(defvar dot-mode-cmd-keys nil + "Saved keys.") + +(defvar dot-mode-state 0 + "Current state of dot mode. +0 - Initial (no changes) +1 - Recording buffer changes +2 - Override from state 0 +3 - Override from state 1") + +(defvar dot-mode-minibuffer-input nil + "Global buffer to capture minibuffer input") + +(defvar dot-mode-verbose t + "Message the user every time a repeat happens") + +;; n.b. This is a little tricky ... when the prefix-argument is changed it +;; doesn't leave much of a trace. It resets `this-command' and +;; `real-this-command' to the previous ones. +;; Hence the best way (that I know of) to tell whether the last command was +;; changing the prefix is by adding a hook into +;; `prefix-command-preserve-state-hook'. +(defvar dot-mode-prefix-arg nil + "Marker variable to show the prefix argument has been changed.") + +(defvar dot-mode-argument-buffer nil + "Global buffer to store current digit argument.") + +(defun dot-mode-buffer-to-string () + "Return the macro buffer as a string." + (kmacro-display dot-mode-cmd-buffer)) + +(defun dot-mode-minibuffer-exit () + "Catch minibuffer exit" + ;; I'd really like to check `this-command' to see if it's `exit-minibuffer' + ;; and remove this function from the `minibuffer-exit-hook' if it is. + ;; Unfortunately, if an extended command asks for 2 or more arguments, + ;; the first arg would be the only one to get recorded since `exit-minibuffer' + ;; is called between each argument. + (push (minibuffer-contents) dot-mode-minibuffer-input)) + +(defun dot-mode-after-change (start end prevlen) + "Dot mode's `after-change-functions' hook" + ;; By the time we get here, `dot-mode-pre-hook' has already setup + ;; `dot-mode-cmd-keys.' It'll be a `vector', `t', or `nil'. + (cond ((vectorp dot-mode-cmd-keys) + ;; We just did `execute-extended-command' or an override. + ;; If we're in override, the keys have already been read and + ;; `dot-mode-changed' is `t' + (unless dot-mode-changed + (remove-hook 'minibuffer-exit-hook 'dot-mode-minibuffer-exit) + (unless (null dot-mode-minibuffer-input) + ;; The first item in this list is what was in the minibuffer + ;; after choosing the command from either + ;; `execute-extended-command' or `smex'. + ;; This may very well not be the name of the command, so we + ;; replace it with the head of the list + ;; `extended-command-history'. + (setq dot-mode-cmd-keys + (vconcat dot-mode-cmd-keys + (mapconcat + #'identity + (cons (car extended-command-history) + (cdr (nreverse dot-mode-minibuffer-input))) + "\r")))))) + ;; Normal mode + (dot-mode-cmd-keys + (setq dot-mode-cmd-keys (this-command-keys-vector)))) + ;; Else, do nothing `dot-mode-cmd-keys' will remain `nil'. + ;; (Only happens on `ignore-undo') + (when dot-mode-cmd-keys + (setq dot-mode-changed t))) + +(defun dot-mode-pre-hook () + "Dot mode's `pre-command-hook'" + + ;; remove hook (should already be removed... but double check) + ;; The only time this will ever do any good is if you did a + ;; quit out of the minibuffer. In that case, the hook will + ;; still be there. It won't really hurt anything, it will just + ;; continue to record everything you do in the minibuffer + ;; regardless of whether or not it is an `execute-extended-command'. + ;; And the `dot-mode-minibuffer-input' buffer could get quite large. + (remove-hook 'minibuffer-exit-hook 'dot-mode-minibuffer-exit) + + (cond + ;; Is this an `execute-extended-command' or `smex'? + ((member this-command '(execute-extended-command smex)) + (setq dot-mode-minibuffer-input nil + ;; Must get this (M-x) now! It's gone later. + dot-mode-cmd-keys (this-command-keys-vector) + ;; ignore an override + dot-mode-changed nil) + ;; Must be a global hook + (add-hook 'minibuffer-exit-hook 'dot-mode-minibuffer-exit)) + (dot-mode-changed ;; on override, `dot-mode-changed' is t + ;; Always read the keys here on override _UNLESS_ it's a `quoted-insert'. + ;; This is to make sure we capture keys that don't change the buffer. + ;; On `quoted-insert', all we get here is , but in `dot-mode-after-change', + ;; we get  plus the following key (and we're guaranteed to change the + ;; buffer) + (setq dot-mode-cmd-keys (or (eq this-command 'quoted-insert) + (this-command-keys-vector)))) + ;; Should we ignore this key sequence? (is it an undo?) + ((and dot-mode-ignore-undo + (member this-command '(advertised-undo undo undo-tree-undo undo-tree-redo))) + (setq dot-mode-cmd-keys nil)) + ;; signal to read later (in `dot-mode-after-change') + (t (setq dot-mode-cmd-keys t)))) + +;; (defun dot-mode--state-name () +;; (nth dot-mode-state '("Initial (no changes)" +;; "Recording buffer changes" +;; "Override from recording" +;; "Override from initial"))) + +(defun dot-mode-prefix-command-hook () (setq dot-mode-prefix-arg t)) +(defun dot-mode-loop () + "The heart of dot mode." + ;; (message "in:\tstate: \"%s\"\n\tcommand: \"%S\"" + ;; (dot-mode--state-name) this-command) + ;; (message "in: cmd-buffer is '%s'" (dot-mode-buffer-to-string)) + + ;; Record all digit-argument and universal-argument functions + (cond (dot-mode-prefix-arg + ;; Keep this keypress around, and don't change the current state + (setq dot-mode-prefix-arg nil + dot-mode-argument-buffer (vconcat dot-mode-argument-buffer (this-command-keys-vector)))) + ((= dot-mode-state 0) ; idle + (if dot-mode-changed + (setq dot-mode-state 1 + dot-mode-changed nil + dot-mode-cmd-buffer (vconcat dot-mode-argument-buffer dot-mode-cmd-keys))) + (setq dot-mode-argument-buffer nil)) + ((= dot-mode-state 1) ; recording + (if dot-mode-changed + (setq dot-mode-changed nil + dot-mode-cmd-buffer (vconcat dot-mode-cmd-buffer dot-mode-argument-buffer dot-mode-cmd-keys)) + (setq dot-mode-state 0)) + (setq dot-mode-argument-buffer nil)) + (t ; = 2 or 3 ; override + (setq dot-mode-state (- dot-mode-state 2) + dot-mode-changed t))) + ;; (message "out: state is \"%s\"" (dot-mode--state-name)) + ;; (message "out: cmd-buffer is '%s'" (dot-mode-buffer-to-string)) + ) + +(defun dot-mode-remove-hooks () + (remove-hook 'pre-command-hook 'dot-mode-pre-hook t) + (remove-hook 'post-command-hook 'dot-mode-loop t) + (remove-hook 'after-change-functions 'dot-mode-after-change t) + (remove-hook 'prefix-command-preserve-state-hook 'dot-mode-prefix-command-hook t)) + +(defun dot-mode-add-hooks () + (add-hook 'pre-command-hook 'dot-mode-pre-hook nil t) + (add-hook 'post-command-hook 'dot-mode-loop nil t) + (add-hook 'after-change-functions 'dot-mode-after-change nil t) + (add-hook 'prefix-command-preserve-state-hook 'dot-mode-prefix-command-hook nil t)) + +;;;###autoload +(defun dot-mode-copy-to-last-kbd-macro () + "Copy the current `dot-mode' command buffer to the `last-kbd-macro' variable. +Then it can be called with `call-last-kbd-macro', named with +`name-last-kbd-macro', or even saved for later use with +`name-last-kbd-macro'" + (interactive) + (if (null dot-mode-cmd-buffer) + (message "Nothing to copy.") + (setq last-kbd-macro dot-mode-cmd-buffer) + (message "Copied."))) + +;;;###autoload +(defun dot-mode-execute () + "Execute stored commands." + (interactive) + ;; Don't want execution to kick off infinite recursion + (if (null dot-mode-cmd-buffer) + (message "Nothing to repeat") + (dot-mode-remove-hooks) + ;; Do the business + (when dot-mode-verbose + (message "Repeating \"%s\"" (dot-mode-buffer-to-string))) + (condition-case nil + (execute-kbd-macro dot-mode-cmd-buffer) + ((error quit exit) + (setq dot-mode-cmd-buffer nil + dot-mode-state 0) + (message "Dot mode reset"))) + (if (and (not (null dot-mode-cmd-buffer)) + dot-mode-verbose) + ;; I message before AND after a macro execution. + ;; This way you'll know if your macro somehow + ;; hangs during execution. + (message "Repeated \"%s\"" (dot-mode-buffer-to-string))) + ;; Put the hooks back + (dot-mode-add-hooks))) + +;;;###autoload +(defun dot-mode-override () + "Unconditionally store next keystroke." + (interactive) + (setq dot-mode-state (+ dot-mode-state 2)) + ;; If dot-mode-argument-buffer is non nil then we were in the middle (or at + ;; the end of a argument chain). In that case we take care to not break it. + ;; If it is `nil', then `universal-argument--mode' was not previously active, + ;; and we don't activate it in order to avoid changing behaviour. + ;; n.b. We're checking `dot-mode-argument-buffer' as a variable that happens + ;; to be `nil' when we weren't in an argument chain, it's *not* the "thing + ;; we're interested in". + (when dot-mode-argument-buffer + ;; The docstring of `prefix-command-update' says we need to call it whenever + ;; we change the "prefix command state". + (progn(prefix-command-update) + (setq prefix-arg current-prefix-arg) + (universal-argument--mode))) + (message "dot-mode will remember the next keystroke...")) + +;;;###autoload +(define-minor-mode dot-mode + "Dot mode mimics the `.' function in vi, repeating sequences of +commands and/or typing delimited by motion events. Use `C-.' +rather than just `.'." nil " Dot" + (let ((map (make-sparse-keymap))) + (define-key map (kbd "C-.") 'dot-mode-execute) + (define-key map (kbd "C-M-.") 'dot-mode-override) + (define-key map (kbd "C-c .") 'dot-mode-copy-to-last-kbd-macro) + map) + (if (not dot-mode) + (dot-mode-remove-hooks) + (dot-mode-add-hooks) + (if dot-mode-global-mode + (progn + (kill-local-variable 'dot-mode-cmd-buffer) + (kill-local-variable 'dot-mode-cmd-keys) + (kill-local-variable 'dot-mode-state) + (kill-local-variable 'dot-mode-changed) + (kill-local-variable 'dot-mode-prefix-arg) + (kill-local-variable 'dot-mode-argument-buffer)) + ;; ELSE + (make-local-variable 'dot-mode-cmd-buffer) + (make-local-variable 'dot-mode-cmd-keys) + (make-local-variable 'dot-mode-state) + (make-local-variable 'dot-mode-changed) + (make-local-variable 'dot-mode-prefix-arg) + (make-local-variable 'dot-mode-argument-buffer) + (setq dot-mode-state 0 + dot-mode-changed nil + dot-mode-cmd-buffer nil + dot-mode-cmd-keys nil + dot-mode-prefix-arg nil + dot-mode-argument-buffer nil)))) + +;;;###autoload +(defun dot-mode-on () + "Turn on dot-mode." + (interactive) + ;; Ignore internal buffers -- this stops modifications in the echo area being + ;; recorded as a macro that gets used elsewhere. + (unless (or (eq ?\ (aref (buffer-name) 0)) + ;; Also ignore the *Messages* buffer -- when `dot-mode' is enabled + ;; here some recursion happens due to the `after-change-functions' + ;; in that buffer getting called. + (eq (current-buffer) (messages-buffer)) + ;; I suspect all minibuffers will have a space at the start of + ;; their buffer name, and hence I won't need this check. + ;; Unfortunately I can't find any documentation + ;; disproving/confirming this, so we include this check. + (minibufferp)) + (dot-mode 1))) + +;;;###autoload +(defalias 'turn-on-dot-mode 'dot-mode-on) +;;;###autoload +(define-global-minor-mode global-dot-mode dot-mode dot-mode-on) + +(provide 'dot-mode) + +;;; dot-mode.el ends here diff --git a/elpa/dot-mode-20180312.2300/dot-mode.elc b/elpa/dot-mode-20180312.2300/dot-mode.elc new file mode 100644 index 0000000000000000000000000000000000000000..2a65a362047041b083b2b4d43f4d35d798545673 GIT binary patch literal 11248 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. + +;;; Commentary: +;; +;; A major mode for plantuml, see: http://plantuml.sourceforge.net/ +;; Plantuml is an open-source tool in java that allows to quickly write : +;; - sequence diagram, +;; - use case diagram, +;; - class diagram, +;; - activity diagram, +;; - component diagram, +;; - state diagram +;; - object diagram + +;;; Change log: +;; +;; version 1.4.1, 2019-09-03 Better indentation; more bugfixing; actually adding `executable' mode +;; version 1.4.0, 2019-08-21 Added `executable' exec mode to use locally installed `plantuml' binaries, various bugfixes +;; version 1.3.1, 2019-08-02 Fixed interactive behavior of `plantuml-set-exec-mode' +;; version 1.3.0, 2019-05-31 Added experimental support for multiple rendering modes and, specifically, preview using a PlantUML server +;; version 1.2.11, 2019-04-09 Added `plantuml-download-jar' +;; version 1.2.10, 2019-04-03 Avoid messing with window layouts and buffers -- courtesy of https://github.com/wailo +;; version 1.2.9, Revamped indentation support, now working with a greater number of keywords +;; version 1.2.8, 2019-01-07 Support indentation for activate / deactivate blocks; allow customization of `plantuml-java-args' +;; version 1.2.7, 2018-08-15 Added support for indentation; Fixed the comiling error when installing with melpa +;; version 1.2.6, 2018-07-17 Introduced custom variable `plantuml-jar-args' to control which arguments are passed to PlantUML jar. Fix the warning of failing to specify types of 'defcustom' variables +;; version 1.2.5, 2017-08-19 #53 Fixed installation warnings +;; version 1.2.4, 2017-08-18 #60 Licensed with GPLv3+ to be compatible with Emacs +;; version 1.2.3, 2016-12-25 #50 unicode support in generated output +;; version 1.2.2, 2016-11-11 Fixed java commands handling under windows; support spaces in `plantuml-jar-path' +;; version 1.2.1, 2016-11-11 Support for paths like `~/.plantuml/plantuml.jar' for `plantuml-jar-path' (the tilde was previously unsupported) +;; version 1.2.0, 2016-11-09 Added `plantuml-preview-current-buffer', courtesy of @7mamu4 +;; version 1.1.1, 2016-11-08 Fix process handling with Windows native emacs; better file extention match for autoloading the mode +;; version 1.1.0, 2016-10-18 Make PlantUML run headless by default; introduced custom variable `plantuml-java-args' to control which arguments are passed to Plantuml. +;; version 1.0.1, 2016-10-17 Bugfix release: proper auto-mode-alist regex; init delayed at mode load; avoid calling hooks twice. +;; version 1.0.0, 2016-10-16 Moved the mode to plantuml-mode, superseding zwz/plantuml-mode and skuro/puml-mode. Added preview for the currently selected region. +;; version 0.6.7, 2016-10-11 [from puml-mode] Added deprecation warning in favor of plantuml-mode +;; version 0.6.6, 2016-07-19 [from puml-mode] Added autoload, minor bug fixes +;; version 0.6.5, 2016-03-24 [from puml-mode] Added UTF8 support and open in new window / frame shortcuts +;; version 0.6.4, 2015-12-12 [from puml-mode] Added support for comments (single and multiline) -- thanks to https://github.com/nivekuil +;; version 0.6.3, 2015-11-07 [from puml-mode] Added per-buffer configurability of output type (thanks to https://github.com/davazp) +;; version 0.6.2, 2015-11-07 [from puml-mode] Added debugging capabilities to improve issue analysis +;; version 0.6.1, 2015-09-26 [from puml-mode] Bugfix: use eq to compare symbols instead of cl-equalp +;; version 0.6, 2015-09-26 [from puml-mode] Fixed PNG preview +;; version 0.5, 2015-09-21 [from puml-mode] Added preview capabilities +;; version 0.4, 2015-06-14 [from puml-mode] Use a puml- prefix to distinguish from the other plantuml-mode +;; version 0.3, 2015-06-13 [from puml-mode] Compatibility with Emacs 24.x +;; version 0.2, 2010-09-20 [from puml-mode] Initialize the keywords from the -language output of plantuml.jar instead of the hard-coded way. +;; version 0.1, 2010-08-25 [from puml-mode] First version + +;;; Code: +(require 'thingatpt) +(require 'dash) +(require 'xml) + +(defgroup plantuml-mode nil + "Major mode for editing plantuml file." + :group 'languages) + +(defcustom plantuml-jar-path + (expand-file-name "~/plantuml.jar") + "The location of the PlantUML executable JAR." + :type 'string + :group 'plantuml) + +(defcustom plantuml-executable-path + "plantuml" + "The location of the PlantUML executable." + :type 'string + :group 'plantuml) + +(defvar plantuml-mode-hook nil "Standard hook for plantuml-mode.") + +(defconst plantuml-mode-version "20190905.838" "The plantuml-mode version string.") + +(defvar plantuml-mode-debug-enabled nil) + +(defvar plantuml-font-lock-keywords nil) + +(defvar plantuml-mode-map + (let ((keymap (make-sparse-keymap))) + (define-key keymap (kbd "C-c C-c") 'plantuml-preview) + keymap) + "Keymap for plantuml-mode.") + +(defcustom plantuml-java-command "java" + "The java command used to execute PlantUML." + :type 'string + :group 'plantuml) + +(defcustom plantuml-java-args (list "-Djava.awt.headless=true" "-jar" "--illegal-access=deny") + "The parameters passed to `plantuml-java-command' when executing PlantUML." + :type '(repeat string) + :group 'plantuml) + +(defcustom plantuml-jar-args (list "-charset" "UTF-8" ) + "The parameters passed to `plantuml.jar', when executing PlantUML." + :type '(repeat string) + :group 'plantuml) + +(defcustom plantuml-server-url "https://www.plantuml.com/plantuml" + "The base URL of the PlantUML server." + :type 'string + :group 'plantuml) + +(defcustom plantuml-executable-args (list "-headless") + "The parameters passed to plantuml executable when executing PlantUML." + :type '(repeat string) + :group 'plantuml) + +(defcustom plantuml-default-exec-mode 'server + "Default execution mode for PlantUML. Valid values are: +- `jar': run PlantUML as a JAR file (requires a local install of the PlantUML JAR file, see `plantuml-jar-path'" + :type 'symbol + :group 'plantuml + :options '(jar server executable)) + +(defcustom plantuml-suppress-deprecation-warning t + "To silence the deprecation warning when `puml-mode' is found upon loading." + :type 'boolean + :group 'plantuml) + +(defcustom plantuml-indent-level 8 + "Indentation level of PlantUML lines") + +(defun plantuml-jar-render-command (&rest arguments) + "Create a command line to execute PlantUML with arguments (as ARGUMENTS)." + (let* ((cmd-list (append plantuml-java-args (list (expand-file-name plantuml-jar-path)) plantuml-jar-args arguments)) + (cmd (mapconcat 'identity cmd-list "|"))) + (plantuml-debug (format "Command is [%s]" cmd)) + cmd-list)) + +;;; syntax table +(defvar plantuml-mode-syntax-table + (let ((synTable (make-syntax-table))) + (modify-syntax-entry ?\/ ". 14c" synTable) + (modify-syntax-entry ?' "< 23" synTable) + (modify-syntax-entry ?\n ">" synTable) + (modify-syntax-entry ?\r ">" synTable) + (modify-syntax-entry ?! "w" synTable) + (modify-syntax-entry ?@ "w" synTable) + (modify-syntax-entry ?# "'" synTable) + synTable) + "Syntax table for `plantuml-mode'.") + +(defvar plantuml-types nil) +(defvar plantuml-keywords nil) +(defvar plantuml-preprocessors nil) +(defvar plantuml-builtins nil) + +;; keyword completion +(defvar plantuml-kwdList nil "The plantuml keywords.") + +;; PlantUML execution mode +(defvar-local plantuml-exec-mode nil + "The Plantuml execution mode override. See `plantuml-default-exec-mode' for acceptable values.") + +(defun plantuml-set-exec-mode (mode) + "Set the execution mode MODE for PlantUML." + (interactive (let* ((completion-ignore-case t) + (supported-modes '("jar" "server" "executable"))) + (list (completing-read (format "Exec mode [%s]: " plantuml-exec-mode) + supported-modes + nil + t + nil + nil + plantuml-exec-mode)))) + (if (member mode '("jar" "server" "executable")) + (setq plantuml-exec-mode (intern mode)) + (error (concat "Unsupported mode:" mode)))) + +(defun plantuml-get-exec-mode () + "Retrieves the currently active PlantUML exec mode." + (or plantuml-exec-mode + plantuml-default-exec-mode)) + +(defun plantuml-enable-debug () + "Enables debug messages into the *PLANTUML Messages* buffer." + (interactive) + (setq plantuml-mode-debug-enabled t)) + +(defun plantuml-disable-debug () + "Stops any debug messages to be added into the *PLANTUML Messages* buffer." + (interactive) + (setq plantuml-mode-debug-enabled nil)) + +(defun plantuml-debug (msg) + "Writes msg (as MSG) into the *PLANTUML Messages* buffer without annoying the user." + (if plantuml-mode-debug-enabled + (let* ((log-buffer-name "*PLANTUML Messages*") + (log-buffer (get-buffer-create log-buffer-name))) + (save-excursion + (with-current-buffer log-buffer + (goto-char (point-max)) + (insert msg) + (insert "\n")))))) + +(defun plantuml-download-jar () + "Download the latest PlantUML JAR file and install it into `plantuml-jar-path'." + (interactive) + (if (y-or-n-p (format "Download the latest PlantUML JAR file into %s? " plantuml-jar-path)) + (if (or (not (file-exists-p plantuml-jar-path)) + (y-or-n-p (format "The PlantUML jar file already exists at %s, overwrite? " plantuml-jar-path))) + (with-current-buffer (url-retrieve-synchronously "https://search.maven.org/solrsearch/select?q=g:net.sourceforge.plantuml+AND+a:plantuml&core=gav&start=0&rows=1&wt=xml") + (mkdir (file-name-directory plantuml-jar-path) t) + (let* ((parse-tree (xml-parse-region)) + (doc (->> parse-tree + (assq 'response) + (assq 'result) + (assq 'doc))) + (strs (xml-get-children doc 'str)) + (version (->> strs + (--filter (string-equal "v" (xml-get-attribute it 'name))) + (car) + (xml-node-children) + (car)))) + (message (concat "Downloading PlantUML v" version " into " plantuml-jar-path)) + (url-copy-file (format "https://search.maven.org/remotecontent?filepath=net/sourceforge/plantuml/plantuml/%s/plantuml-%s.jar" version version) plantuml-jar-path t) + (kill-buffer))) + (message "Aborted.")) + (message "Aborted."))) + +(defun plantuml-jar-java-version () + "Inspects the Java runtime version of the configured Java command in `plantuml-java-command'." + (save-excursion + (save-match-data + (with-temp-buffer + (call-process plantuml-java-command nil t nil "-XshowSettings:properties" "-version") + (re-search-backward "java.version = \\(1.\\)?\\([[:digit:]]+\\)") + (string-to-number (match-string 2)))))) + +(defun plantuml-jar-get-language (buf) + "Retrieve the language specification from the PlantUML JAR file and paste it into BUF." + (unless (or (eq system-type 'cygwin) (file-exists-p plantuml-jar-path)) + (error "Could not find plantuml.jar at %s" plantuml-jar-path)) + (with-current-buffer buf + (let ((cmd-args (append (list plantuml-java-command nil t nil) + (plantuml-jar-render-command "-language")))) + (apply 'call-process cmd-args) + (goto-char (point-min))))) + +(defun plantuml-server-get-language (buf) + "Retrieve the language specification from the PlantUML server and paste it into BUF." + (let ((lang-url (concat plantuml-server-url "/language"))) + (with-current-buffer buf + (url-insert-file-contents lang-url)))) + +(defun plantuml-executable-get-language (buf) + "Retrieve the language specification from the PlantUML executable and paste it into BUF." + (with-current-buffer buf + (let ((cmd-args (append (list plantuml-executable-path nil t nil) (list "-language")))) + (apply 'call-process cmd-args) + (goto-char (point-min))))) + +(defun plantuml-get-language (mode buf) + "Retrieve the language spec using the preferred PlantUML execution mode MODE. Paste the result into BUF." + (let ((get-fn (pcase mode + ('jar #'plantuml-jar-get-language) + ('server #'plantuml-server-get-language) + ('executable #'plantuml-executable-get-language)))) + (if get-fn + (funcall get-fn buf) + (error "Unsupported execution mode %s" mode)))) + +(defun plantuml-init (mode) + "Initialize the keywords or builtins from the cmdline language output. Use exec mode MODE to load the language details." + (with-temp-buffer + (plantuml-get-language mode (current-buffer)) + (let ((found (search-forward ";" nil t)) + (word "") + (count 0) + (pos 0)) + (while found + (forward-char) + (setq word (current-word)) + (if (string= word "EOF") (setq found nil) + ;; else + (forward-line) + (setq count (string-to-number (current-word))) + (beginning-of-line 2) + (setq pos (point)) + (forward-line count) + (cond ((string= word "type") + (setq plantuml-types + (split-string + (buffer-substring-no-properties pos (point))))) + ((string= word "keyword") + (setq plantuml-keywords + (split-string + (buffer-substring-no-properties pos (point))))) + ((string= word "preprocessor") + (setq plantuml-preprocessors + (split-string + (buffer-substring-no-properties pos (point))))) + (t (setq plantuml-builtins + (append + plantuml-builtins + (split-string + (buffer-substring-no-properties pos (point))))))) + (setq found (search-forward ";" nil nil))))))) + +(defconst plantuml-preview-buffer "*PLANTUML Preview*") + +(defvar plantuml-output-type + (if (not (display-images-p)) + "txt" + (cond ((image-type-available-p 'svg) "svg") + ((image-type-available-p 'png) "png") + (t "txt"))) + "Specify the desired output type to use for generated diagrams.") + +(defun plantuml-read-output-type () + "Read from the minibuffer a output type." + (let* ((completion-ignore-case t) + (available-types + (append + (and (image-type-available-p 'svg) '("svg")) + (and (image-type-available-p 'png) '("png")) + '("txt")))) + (completing-read (format "Output type [%s]: " plantuml-output-type) + available-types + nil + t + nil + nil + plantuml-output-type))) + +(defun plantuml-set-output-type (type) + "Set the desired output type (as TYPE) for the current buffer. +If the +major mode of the current buffer mode is not plantuml-mode, set the +default output type for new buffers." + (interactive (list (plantuml-read-output-type))) + (setq plantuml-output-type type)) + +(defun plantuml-is-image-output-p () + "Return non-nil if the diagram output format is an image, false if it's text based." + (not (equal "txt" plantuml-output-type))) + +(defun plantuml-jar-output-type-opt (output-type) + "Create the flag to pass to PlantUML according to OUTPUT-TYPE. +Note that output type `txt' is promoted to `utxt' for better rendering." + (concat "-t" (pcase output-type + ("txt" "utxt") + (_ output-type)))) + +(defun plantuml-jar-start-process (buf) + "Run PlantUML as an Emacs process and puts the output into the given buffer (as BUF)." + (let ((java-args (if (<= 8 (plantuml-jar-java-version)) + (remove "--illegal-access=deny" plantuml-java-args) + plantuml-java-args))) + (apply #'start-process + "PLANTUML" buf plantuml-java-command + `(,@java-args + ,(expand-file-name plantuml-jar-path) + ,(plantuml-jar-output-type-opt plantuml-output-type) + ,@plantuml-jar-args + "-p")))) + +(defun plantuml-executable-start-process (buf) + "Run PlantUML as an Emacs process and puts the output into the given buffer (as BUF)." + (apply #'start-process + "PLANTUML" buf plantuml-executable-path + `(,@plantuml-executable-args + ,(plantuml-jar-output-type-opt plantuml-output-type) + "-p"))) + +(defun plantuml-update-preview-buffer (prefix buf) + "Show the preview in the preview buffer BUF. +Window is selected according to PREFIX: +- 4 (when prefixing the command with C-u) -> new window +- 16 (when prefixing the command with C-u C-u) -> new frame. +- else -> new buffer" + (let ((imagep (and (display-images-p) + (plantuml-is-image-output-p)))) + (cond + ((= prefix 16) (switch-to-buffer-other-frame buf)) + ((= prefix 4) (switch-to-buffer-other-window buf)) + (t (display-buffer buf))) + (when imagep + (with-current-buffer buf + (image-mode) + (set-buffer-multibyte t))))) + +(defun plantuml-jar-preview-string (prefix string buf) + "Preview the diagram from STRING by running the PlantUML JAR. +Put the result into buffer BUF. Window is selected according to PREFIX: +- 4 (when prefixing the command with C-u) -> new window +- 16 (when prefixing the command with C-u C-u) -> new frame. +- else -> new buffer" + (let* ((process-connection-type nil) + (ps (plantuml-jar-start-process buf))) + (process-send-string ps string) + (process-send-eof ps) + (set-process-sentinel ps + (lambda (_ps event) + (unless (equal event "finished\n") + (error "PLANTUML Preview failed: %s" event)) + (plantuml-update-preview-buffer prefix buf))))) + +(defun plantuml-server-encode-url (string) + "Encode the string STRING into a URL suitable for PlantUML server interactions." + (let* ((coding-system (or buffer-file-coding-system + "utf8")) + (encoded-string (base64-encode-string (encode-coding-string string coding-system) t))) + (concat plantuml-server-url "/" plantuml-output-type "/-base64-" encoded-string))) + +(defun plantuml-server-preview-string (prefix string buf) + "Preview the diagram from STRING as rendered by the PlantUML server. +Put the result into buffer BUF and place it according to PREFIX: +- 4 (when prefixing the command with C-u) -> new window +- 16 (when prefixing the command with C-u C-u) -> new frame. +- else -> new buffer" + (let* ((url-request-location (plantuml-server-encode-url string))) + (save-current-buffer + (save-match-data + (url-retrieve url-request-location + (lambda (status) + ;; TODO: error check + (goto-char (point-min)) + ;; skip the HTTP headers + (while (not (looking-at "\n")) + (forward-line)) + (kill-region (point-min) (+ 1 (point))) + (copy-to-buffer buf (point-min) (point-max)) + (plantuml-update-preview-buffer prefix buf))))))) + +(defun plantuml-executable-preview-string (prefix string buf) + "Preview the diagram from STRING by running the PlantUML JAR. +Put the result into buffer BUF. Window is selected according to PREFIX: +- 4 (when prefixing the command with C-u) -> new window +- 16 (when prefixing the command with C-u C-u) -> new frame. +- else -> new buffer" + (let* ((process-connection-type nil) + (ps (plantuml-executable-start-process buf))) + (process-send-string ps string) + (process-send-eof ps) + (set-process-sentinel ps + (lambda (_ps event) + (unless (equal event "finished\n") + (error "PLANTUML Preview failed: %s" event)) + (plantuml-update-preview-buffer prefix buf))))) + +(defun plantuml-exec-mode-preview-string (prefix mode string buf) + "Preview the diagram from STRING using the execution mode MODE. +Put the result into buffer BUF, selecting the window according to PREFIX: +- 4 (when prefixing the command with C-u) -> new window +- 16 (when prefixing the command with C-u C-u) -> new frame. +- else -> new buffer" + (let ((preview-fn (pcase mode + ('jar #'plantuml-jar-preview-string) + ('server #'plantuml-server-preview-string) + ('executable #'plantuml-executable-preview-string)))) + (if preview-fn + (funcall preview-fn prefix string buf) + (error "Unsupported execution mode %s" mode)))) + +(defun plantuml-preview-string (prefix string) + "Preview diagram from PlantUML sources (as STRING), using prefix (as PREFIX) +to choose where to display it." + (let ((b (get-buffer plantuml-preview-buffer))) + (when b + (kill-buffer b))) + + (let* ((imagep (and (display-images-p) + (plantuml-is-image-output-p))) + (buf (get-buffer-create plantuml-preview-buffer)) + (coding-system-for-read (and imagep 'binary)) + (coding-system-for-write (and imagep 'binary))) + (plantuml-exec-mode-preview-string prefix (plantuml-get-exec-mode) string buf))) + +(defun plantuml-preview-buffer (prefix) + "Preview diagram from the PlantUML sources in the current buffer. +Uses prefix (as PREFIX) to choose where to display it: +- 4 (when prefixing the command with C-u) -> new window +- 16 (when prefixing the command with C-u C-u) -> new frame. +- else -> new buffer" + (interactive "p") + (plantuml-preview-string prefix (buffer-string))) + +(defun plantuml-preview-region (prefix begin end) + "Preview diagram from the PlantUML sources in from BEGIN to END. +Uses the current region when called interactively. +Uses prefix (as PREFIX) to choose where to display it: +- 4 (when prefixing the command with C-u) -> new window +- 16 (when prefixing the command with C-u C-u) -> new frame. +- else -> new buffer" + (interactive "p\nr") + (plantuml-preview-string prefix (concat "@startuml\n" + (buffer-substring-no-properties + begin end) + "\n@enduml"))) + +(defun plantuml-preview-current-block (prefix) + "Preview diagram from the PlantUML sources from the previous @startuml to the next @enduml. +Uses prefix (as PREFIX) to choose where to display it: +- 4 (when prefixing the command with C-u) -> new window +- 16 (when prefixing the command with C-u C-u) -> new frame. +- else -> new buffer" + (interactive "p") + (save-restriction + (narrow-to-region + (search-backward "@startuml") (search-forward "@enduml")) + (plantuml-preview-buffer prefix))) + +(defun plantuml-preview (prefix) + "Preview diagram from the PlantUML sources. +Uses the current region if one is active, or the entire buffer otherwise. +Uses prefix (as PREFIX) to choose where to display it: +- 4 (when prefixing the command with C-u) -> new window +- 16 (when prefixing the command with C-u C-u) -> new frame. +- else -> new buffer" + (interactive "p") + (if mark-active + (plantuml-preview-region prefix (region-beginning) (region-end)) + (plantuml-preview-buffer prefix))) + +(defun plantuml-init-once (&optional mode) + "Ensure initialization only happens once. Use exec mode MODE to load the language details or by first querying `plantuml-get-exec-mode'." + (let ((mode (or mode (plantuml-get-exec-mode)))) + (unless plantuml-kwdList + (plantuml-init mode) + (defvar plantuml-types-regexp (concat "^\\s *\\(" (regexp-opt plantuml-types 'words) "\\|\\<\\(note\\s +over\\|note\\s +\\(left\\|right\\|bottom\\|top\\)\\s +\\(of\\)?\\)\\>\\|\\<\\(\\(left\\|center\\|right\\)\\s +\\(header\\|footer\\)\\)\\>\\)")) + (defvar plantuml-keywords-regexp (concat "^\\s *" (regexp-opt plantuml-keywords 'words) "\\|\\(<\\|<|\\|\\*\\|o\\)\\(\\.+\\|-+\\)\\|\\(\\.+\\|-+\\)\\(>\\||>\\|\\*\\|o\\)\\|\\.\\{2,\\}\\|-\\{2,\\}")) + (defvar plantuml-builtins-regexp (regexp-opt plantuml-builtins 'words)) + (defvar plantuml-preprocessors-regexp (concat "^\\s *" (regexp-opt plantuml-preprocessors 'words))) + + ;; Below are the regexp's for indentation. + ;; Notes: + ;; - there is some control on what it is indented by overriding some of below + ;; X-start and X-end regexp before plantuml-mode is loaded. E.g., to disable + ;; indentation on activate, you might define in your .emacs something like + ;; (setq plantuml-indent-regexp-activate-start + ;; "NEVER MATCH THIS EXPRESSION"); define _before_ load plantuml-mode! + ;; (setq plantuml-indent-regexp-activate-end + ;; "NEVER MATCH THIS EXPRESSION"); define _before_ load plantuml-mode! + ;; - due to the nature of using (context-insensitive) regexp, indentation have + ;; following limitations + ;; - commands commented out by /' ... '/ will _not_ be ignored + ;; and potentially lead to miss-indentation + ;; - you can though somewhat correct mis-indentation by adding in '-comment lines + ;; PLANTUML_MODE_INDENT_INCREASE and/or PLANTUML_MODE_INDENT_DECREASE + ;; to increase and/or decrease the level of indentation + ;; (Note: the line with the comment should not contain any text matching other indent + ;; regexp or this user-control instruction will be ignored; also at most will count + ;; per line ...) + (defvar plantuml-indent-regexp-block-start "^.*{\s*$" + "Indentation regex for all plantuml elements that might define a {} block. +Plantuml elements like skinparam, rectangle, sprite, package, etc. +The opening { has to be the last visible character in the line (whitespace +might follow).") + (defvar plantuml-indent-regexp-note-start "^\s*\\(floating\s+\\)?[hr]?note\s+\\(right\\|left\\|top\\|bottom\\|over\\)[^:]*?$" "simplyfied regex; note syntax is especially inconsistent across diagrams") + (defvar plantuml-indent-regexp-group-start "^\s*\\(alt\\|else\\|opt\\|loop\\|par\\|break\\|critical\\|group\\)\\(?:\s+.+\\|$\\)" + "Indentation regex for plantuml group elements that are defined for sequence diagrams. +Two variants for groups: keyword is either followed by whitespace and some text +or it is followed by line end.") + (defvar plantuml-indent-regexp-activate-start "^\s*activate\s+.+$") + (defvar plantuml-indent-regexp-box-start "^\s*box\s+.+$") + (defvar plantuml-indent-regexp-ref-start "^\s*ref\s+over\s+[^:]+?$") + (defvar plantuml-indent-regexp-title-start "^\s*title\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-header-start "^\s*\\(?:\\(?:center\\|left\\|right\\)\s+header\\|header\\)\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-footer-start "^\s*\\(?:\\(?:center\\|left\\|right\\)\s+footer\\|footer\\)\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-legend-start "^\s*\\(?:legend\\|legend\s+\\(?:bottom\\|top\\)\\|legend\s+\\(?:center\\|left\\|right\\)\\|legend\s+\\(?:bottom\\|top\\)\s+\\(?:center\\|left\\|right\\)\\)\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-oldif-start "^.*if\s+\".*\"\s+then\s*\\('.*\\)?$" "used in current activity diagram, sometimes already mentioned as deprecated") + (defvar plantuml-indent-regexp-newif-start "^\s*\\(?:else\\)?if\s+(.*)\s+then\s*.*$") + (defvar plantuml-indent-regexp-loop-start "^\s*\\(?:repeat\s*\\|while\s+(.*).*\\)$") + (defvar plantuml-indent-regexp-fork-start "^\s*\\(?:fork\\|split\\)\\(?:\s+again\\)?\s*$") + (defvar plantuml-indent-regexp-macro-start "^\s*!definelong.*$") + (defvar plantuml-indent-regexp-user-control-start "^.*'.*\s*PLANTUML_MODE_INDENT_INCREASE\s*.*$") + (defvar plantuml-indent-regexp-start (list plantuml-indent-regexp-block-start + plantuml-indent-regexp-group-start + plantuml-indent-regexp-activate-start + plantuml-indent-regexp-box-start + plantuml-indent-regexp-ref-start + plantuml-indent-regexp-legend-start + plantuml-indent-regexp-note-start + plantuml-indent-regexp-newif-start + plantuml-indent-regexp-loop-start + plantuml-indent-regexp-fork-start + plantuml-indent-regexp-title-start + plantuml-indent-regexp-header-start + plantuml-indent-regexp-footer-start + plantuml-indent-regexp-macro-start + plantuml-indent-regexp-oldif-start + plantuml-indent-regexp-user-control-start)) + (defvar plantuml-indent-regexp-block-end "^\s*\\(?:}\\|endif\\|else\s*.*\\|end\\)\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-note-end "^\s*\\(end\s+note\\|end[rh]note\\)\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-group-end "^\s*end\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-activate-end "^\s*deactivate\s+.+$") + (defvar plantuml-indent-regexp-box-end "^\s*end\s+box\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-ref-end "^\s*end\s+ref\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-title-end "^\s*end\s+title\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-header-end "^\s*endheader\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-footer-end "^\s*endfooter\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-legend-end "^\s*endlegend\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-oldif-end "^\s*\\(endif\\|else\\)\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-newif-end "^\s*\\(endif\\|elseif\\|else\\)\s*.*$") + (defvar plantuml-indent-regexp-loop-end "^\s*\\(repeat\s*while\\|endwhile\\)\s*.*$") + (defvar plantuml-indent-regexp-fork-end "^\s*\\(\\(fork\\|split\\)\s+again\\|end\s+\\(fork\\|split\\)\\)\s*$") + (defvar plantuml-indent-regexp-macro-end "^\s*!enddefinelong\s*\\('.*\\)?$") + (defvar plantuml-indent-regexp-user-control-end "^.*'.*\s*PLANTUML_MODE_INDENT_DECREASE\s*.*$") + (defvar plantuml-indent-regexp-end (list plantuml-indent-regexp-block-end + plantuml-indent-regexp-group-end + plantuml-indent-regexp-activate-end + plantuml-indent-regexp-box-end + plantuml-indent-regexp-ref-end + plantuml-indent-regexp-legend-end + plantuml-indent-regexp-note-end + plantuml-indent-regexp-newif-end + plantuml-indent-regexp-loop-end + plantuml-indent-regexp-fork-end + plantuml-indent-regexp-title-end + plantuml-indent-regexp-header-end + plantuml-indent-regexp-footer-end + plantuml-indent-regexp-macro-end + plantuml-indent-regexp-oldif-end + plantuml-indent-regexp-user-control-end)) + (setq plantuml-font-lock-keywords + `( + (,plantuml-types-regexp . font-lock-type-face) + (,plantuml-keywords-regexp . font-lock-keyword-face) + (,plantuml-builtins-regexp . font-lock-builtin-face) + (,plantuml-preprocessors-regexp . font-lock-preprocessor-face) + ;; note: order matters + )) + + (setq plantuml-kwdList (make-hash-table :test 'equal)) + (mapc (lambda (x) (puthash x t plantuml-kwdList)) plantuml-types) + (mapc (lambda (x) (puthash x t plantuml-kwdList)) plantuml-keywords) + (mapc (lambda (x) (puthash x t plantuml-kwdList)) plantuml-builtins) + (mapc (lambda (x) (puthash x t plantuml-kwdList)) plantuml-preprocessors) + (put 'plantuml-kwdList 'risky-local-variable t) + + ;; clear memory + (setq plantuml-types nil) + (setq plantuml-keywords nil) + (setq plantuml-builtins nil) + (setq plantuml-preprocessors nil) + (setq plantuml-types-regexp nil) + (setq plantuml-keywords-regexp nil) + (setq plantuml-builtins-regexp nil) + (setq plantuml-preprocessors-regexp nil)))) + +(defun plantuml-complete-symbol () + "Perform keyword completion on word before cursor." + (interactive) + (let ((posEnd (point)) + (meat (thing-at-point 'symbol)) + maxMatchResult) + + (when (not meat) (setq meat "")) + + (setq maxMatchResult (try-completion meat plantuml-kwdList)) + (cond ((eq maxMatchResult t)) + ((null maxMatchResult) + (message "Can't find completion for \"%s\"" meat) + (ding)) + ((not (string= meat maxMatchResult)) + (delete-region (- posEnd (length meat)) posEnd) + (insert maxMatchResult)) + (t (message "Making completion list...") + (with-output-to-temp-buffer "*Completions*" + (display-completion-list + (all-completions meat plantuml-kwdList))) + (message "Making completion list...%s" "done"))))) + + +;; indentation + + +(defun plantuml-current-block-depth () + "Trace the current block indentation level by recursively looking back line by line." + (save-excursion + (let ((relative-depth 0)) + ;; current line + (beginning-of-line) + (if (-any? 'looking-at plantuml-indent-regexp-end) + (setq relative-depth (1- relative-depth))) + + ;; from current line backwards to beginning of buffer + (while (not (bobp)) + (forward-line -1) + (if (-any? 'looking-at plantuml-indent-regexp-end) + (setq relative-depth (1- relative-depth))) + (if (-any? 'looking-at plantuml-indent-regexp-start) + (setq relative-depth (1+ relative-depth)))) + + (if (<= relative-depth 0) + 0 + relative-depth)))) + +(defun plantuml-indent-line () + "Indent the current line to its desired indentation level. +Restore point to same position in text of the line as before indentation." + (interactive) + ;; store position of point in line measured from end of line + (let ((original-position-eol (- (line-end-position) (point)))) + (save-excursion + (beginning-of-line) + (indent-line-to (* plantuml-indent-level (plantuml-current-block-depth)))) + + ;; restore position in text of line + (goto-char (- (line-end-position) original-position-eol)))) + + +;;;###autoload +(add-to-list 'auto-mode-alist '("\\.\\(plantuml\\|pum\\|plu\\)\\'" . plantuml-mode)) + +;;;###autoload +(define-derived-mode plantuml-mode prog-mode "plantuml" + "Major mode for plantuml. + +Shortcuts Command Name +\\[plantuml-complete-symbol] `plantuml-complete-symbol'" + (plantuml-init-once) + (make-local-variable 'plantuml-output-type) + (set (make-local-variable 'comment-start-skip) "\\('+\\|/'+\\)\\s *") + (set (make-local-variable 'comment-start) "/'") + (set (make-local-variable 'comment-end) "'/") + (set (make-local-variable 'comment-multi-line) t) + (set (make-local-variable 'comment-style) 'extra-line) + (set (make-local-variable 'indent-line-function) 'plantuml-indent-line) + (setq font-lock-defaults '((plantuml-font-lock-keywords) nil t))) + +(defun plantuml-deprecation-warning () + "Warns the user about the deprecation of the `puml-mode' project." + (if (and plantuml-suppress-deprecation-warning + (featurep 'puml-mode)) + (display-warning :warning + "`puml-mode' is now deprecated and no longer updated, but it's still present in your system. \ +You should move your configuration to use `plantuml-mode'. \ +See more at https://github.com/skuro/puml-mode/issues/26"))) + +(add-hook 'plantuml-mode-hook 'plantuml-deprecation-warning) + +(provide 'plantuml-mode) +;;; plantuml-mode.el ends here diff --git a/elpa/plantuml-mode-20191102.2056/plantuml-mode.elc b/elpa/plantuml-mode-20191102.2056/plantuml-mode.elc new file mode 100644 index 0000000000000000000000000000000000000000..389929e994895e6f53b984f9bc3c1915d697799a GIT binary patch literal 30921 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 Hefj?Z6l^Z_ literal 0 HcmV?d00001