You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
297 lines
11 KiB
297 lines
11 KiB
;;; elpy-refactor.el --- Refactoring mode for Elpy
|
|
|
|
;; Copyright (C) 2013-2016 Jorgen Schaefer
|
|
|
|
;; Author: Jorgen Schaefer <contact@jorgenschaefer.de>
|
|
;; URL: https://github.com/jorgenschaefer/elpy
|
|
|
|
;; 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 3
|
|
;; of the License, 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.
|
|
|
|
;; You should have received a copy of the GNU General Public License
|
|
;; along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
;;; Commentary:
|
|
|
|
;; This file provides an interface, including a major mode, to use
|
|
;; refactoring options provided by the Rope library.
|
|
|
|
;;; Code:
|
|
|
|
;; We require elpy, but elpy loads us, so we shouldn't load it back.
|
|
;; (require 'elpy)
|
|
|
|
(defvar elpy-refactor-changes nil
|
|
"Changes that will be commited on \\[elpy-refactor-commit].")
|
|
(make-variable-buffer-local 'elpy-refactor-current-changes)
|
|
|
|
(defvar elpy-refactor-window-configuration nil
|
|
"The old window configuration. Will be restored after commit.")
|
|
(make-variable-buffer-local 'elpy-refactor-window-configuration)
|
|
|
|
(make-obsolete
|
|
'elpy-refactor
|
|
"Refactoring has been unstable and flakey, support will be dropped in the future."
|
|
"elpy 1.5.0")
|
|
(defun elpy-refactor ()
|
|
"Run the Elpy refactoring interface for Python code."
|
|
(interactive)
|
|
(save-some-buffers)
|
|
(let* ((selection (elpy-refactor-select
|
|
(elpy-refactor-rpc-get-options)))
|
|
(method (car selection))
|
|
(args (cdr selection)))
|
|
(when method
|
|
(elpy-refactor-create-change-buffer
|
|
(elpy-refactor-rpc-get-changes method args)))))
|
|
|
|
(defun elpy-refactor-select (options)
|
|
"Show the user the refactoring options and let her choose one.
|
|
|
|
Depending on the chosen option, ask the user for further
|
|
arguments and build the argument.
|
|
|
|
Return a cons cell of the name of the option and the arg list
|
|
created."
|
|
(let ((buf (get-buffer-create "*Elpy Refactor*"))
|
|
(pos (vector (1- (point))
|
|
(ignore-errors
|
|
(1- (region-beginning)))
|
|
(ignore-errors
|
|
(1- (region-end)))))
|
|
(inhibit-read-only t)
|
|
(options (sort options
|
|
(lambda (a b)
|
|
(let ((cata (cdr (assq 'category a)))
|
|
(catb (cdr (assq 'category b))))
|
|
(if (equal cata catb)
|
|
(string< (cdr (assq 'description a))
|
|
(cdr (assq 'description b)))
|
|
(string< cata catb))))))
|
|
(key ?a)
|
|
last-category
|
|
option-alist)
|
|
(with-current-buffer buf
|
|
(erase-buffer)
|
|
(dolist (option options)
|
|
(let ((category (cdr (assq 'category option)))
|
|
(description (cdr (assq 'description option)))
|
|
(name (cdr (assq 'name option)))
|
|
(args (cdr (assq 'args option))))
|
|
(when (not (equal category last-category))
|
|
(when last-category
|
|
(insert "\n"))
|
|
(insert (propertize category 'face 'bold) "\n")
|
|
(setq last-category category))
|
|
(insert " (" key ") " description "\n")
|
|
(setq option-alist (cons (list key name args)
|
|
option-alist))
|
|
(setq key (1+ key))))
|
|
(let ((window-conf (current-window-configuration)))
|
|
(unwind-protect
|
|
(progn
|
|
(with-selected-window (display-buffer buf)
|
|
(goto-char (point-min)))
|
|
(fit-window-to-buffer (get-buffer-window buf))
|
|
(let* ((key (read-key "Refactoring action? "))
|
|
(entry (cdr (assoc key option-alist))))
|
|
(kill-buffer buf)
|
|
(cons (car entry) ; name
|
|
(elpy-refactor-build-arguments (cadr entry)
|
|
pos))))
|
|
(set-window-configuration window-conf))))))
|
|
|
|
(defun elpy-refactor-build-arguments (args pos)
|
|
"Translate an argument list specification to an argument list.
|
|
|
|
POS is a vector of three elements, the current offset, the offset
|
|
of the beginning of the region, and the offset of the end of the
|
|
region.
|
|
|
|
ARGS is a list of triples, each triple containing the name of an
|
|
argument (ignored), the type of the argument, and a possible
|
|
prompt string.
|
|
|
|
Available types:
|
|
|
|
offset - The offset in the buffer, (1- (point))
|
|
start_offset - Offset of the beginning of the region
|
|
end_offset - Offset of the end of the region
|
|
string - A free-form string
|
|
filename - A non-existing file name
|
|
directory - An existing directory name
|
|
boolean - A boolean question"
|
|
(mapcar (lambda (arg)
|
|
(let ((type (cadr arg))
|
|
(prompt (cl-caddr arg)))
|
|
(cond
|
|
((equal type "offset")
|
|
(aref pos 0))
|
|
((equal type "start_offset")
|
|
(aref pos 1))
|
|
((equal type "end_offset")
|
|
(aref pos 2))
|
|
((equal type "string")
|
|
(read-from-minibuffer prompt))
|
|
((equal type "filename")
|
|
(expand-file-name
|
|
(read-file-name prompt)))
|
|
((equal type "directory")
|
|
(expand-file-name
|
|
(read-directory-name prompt)))
|
|
((equal type "boolean")
|
|
(y-or-n-p prompt)))))
|
|
args))
|
|
|
|
(defun elpy-refactor-create-change-buffer (changes)
|
|
"Show the user a buffer of changes.
|
|
|
|
The user can review the changes and confirm them with
|
|
\\[elpy-refactor-commit]."
|
|
(when (not changes)
|
|
(error "No changes for this refactoring action."))
|
|
(with-current-buffer (get-buffer-create "*Elpy Refactor*")
|
|
(elpy-refactor-mode)
|
|
(setq elpy-refactor-changes changes
|
|
elpy-refactor-window-configuration (current-window-configuration))
|
|
(let ((inhibit-read-only t))
|
|
(erase-buffer)
|
|
(elpy-refactor-insert-changes changes))
|
|
(select-window (display-buffer (current-buffer)))
|
|
(goto-char (point-min))))
|
|
|
|
(defun elpy-refactor-insert-changes (changes)
|
|
"Format and display the changes described in CHANGES."
|
|
(insert (propertize "Use C-c C-c to apply the following changes."
|
|
'face 'bold)
|
|
"\n\n")
|
|
(dolist (change changes)
|
|
(let ((action (cdr (assq 'action change))))
|
|
(cond
|
|
((equal action "change")
|
|
(insert (cdr (assq 'diff change))
|
|
"\n"))
|
|
((equal action "create")
|
|
(let ((type (cdr (assq 'type change))))
|
|
(if (equal type "file")
|
|
(insert "+++ " (cdr (assq 'file change)) "\n"
|
|
"Create file " (cdr (assq 'file change)) "\n"
|
|
"\n")
|
|
(insert "+++ " (cdr (assq 'path change)) "\n"
|
|
"Create directory " (cdr (assq 'path change)) "\n"
|
|
"\n"))))
|
|
((equal action "move")
|
|
(insert "--- " (cdr (assq 'source change)) "\n"
|
|
"+++ " (cdr (assq 'destination change)) "\n"
|
|
"Rename " (cdr (assq 'type change)) "\n"
|
|
"\n"))
|
|
((equal action "delete")
|
|
(let ((type (cdr (assq 'type change))))
|
|
(if (equal type "file")
|
|
(insert "--- " (cdr (assq 'file change)) "\n"
|
|
"Delete file " (cdr (assq 'file change)) "\n"
|
|
"\n")
|
|
(insert "--- " (cdr (assq 'path change)) "\n"
|
|
"Delete directory " (cdr (assq 'path change)) "\n"
|
|
"\n"))))))))
|
|
|
|
(defvar elpy-refactor-mode-map
|
|
(let ((map (make-sparse-keymap)))
|
|
(define-key map (kbd "C-c C-c") 'elpy-refactor-commit)
|
|
(define-key map (kbd "q") 'bury-buffer)
|
|
(define-key map (kbd "h") 'describe-mode)
|
|
(define-key map (kbd "?") 'describe-mode)
|
|
map)
|
|
"The key map for `elpy-refactor-mode'.")
|
|
|
|
(define-derived-mode elpy-refactor-mode diff-mode "Elpy Refactor"
|
|
"Mode to display refactoring actions and ask confirmation from the user.
|
|
|
|
\\{elpy-refactor-mode-map}"
|
|
:group 'elpy
|
|
(view-mode 1))
|
|
|
|
(defun elpy-refactor-commit ()
|
|
"Commit the changes in the current buffer."
|
|
(interactive)
|
|
(when (not elpy-refactor-changes)
|
|
(error "No changes to commit."))
|
|
;; Restore the window configuration as the first thing so that
|
|
;; changes below are visible to the user. Especially the point
|
|
;; change in possible buffer changes.
|
|
(set-window-configuration elpy-refactor-window-configuration)
|
|
(dolist (change elpy-refactor-changes)
|
|
(let ((action (cdr (assq 'action change))))
|
|
(cond
|
|
((equal action "change")
|
|
(with-current-buffer (find-file-noselect (cdr (assq 'file change)))
|
|
;; This would break for save-excursion as the buffer is
|
|
;; truncated, so all markets now point to position 1.
|
|
(let ((old-point (point)))
|
|
(undo-boundary)
|
|
(erase-buffer)
|
|
(insert (cdr (assq 'contents change)))
|
|
(undo-boundary)
|
|
(goto-char old-point))))
|
|
((equal action "create")
|
|
(if (equal (cdr (assq 'type change))
|
|
"file")
|
|
(find-file-noselect (cdr (assq 'file change)))
|
|
(make-directory (cdr (assq 'path change)))))
|
|
((equal action "move")
|
|
(let* ((source (cdr (assq 'source change)))
|
|
(dest (cdr (assq 'destination change)))
|
|
(buf (get-file-buffer source)))
|
|
(when buf
|
|
(with-current-buffer buf
|
|
(setq buffer-file-name dest)
|
|
(rename-buffer (file-name-nondirectory dest) t)))
|
|
(rename-file source dest)))
|
|
((equal action "delete")
|
|
(if (equal (cdr (assq 'type change)) "file")
|
|
(let ((name (cdr (assq 'file change))))
|
|
(when (y-or-n-p (format "Really delete %s? " name))
|
|
(delete-file name t)))
|
|
(let ((name (cdr (assq 'directory change))))
|
|
(when (y-or-n-p (format "Really delete %s? " name))
|
|
(delete-directory name nil t))))))))
|
|
(kill-buffer (current-buffer)))
|
|
|
|
(defun elpy-refactor-rpc-get-options ()
|
|
"Get a list of refactoring options from the Elpy RPC."
|
|
(if (use-region-p)
|
|
(elpy-rpc "get_refactor_options"
|
|
(list (buffer-file-name)
|
|
(1- (region-beginning))
|
|
(1- (region-end))))
|
|
(elpy-rpc "get_refactor_options"
|
|
(list (buffer-file-name)
|
|
(1- (point))))))
|
|
|
|
(defun elpy-refactor-rpc-get-changes (method args)
|
|
"Get a list of changes from the Elpy RPC after applying METHOD with ARGS."
|
|
(elpy-rpc "refactor"
|
|
(list (buffer-file-name)
|
|
method args)))
|
|
|
|
(defun elpy-refactor-options (option)
|
|
"Show available refactor options and let user choose one."
|
|
(interactive "c[i]: importmagic-fixup [p]: autopep8-fix-code [r]: refactor")
|
|
(let ((choice (char-to-string option)))
|
|
(cond
|
|
((string-equal choice "i")
|
|
(elpy-importmagic-fixup))
|
|
((string-equal choice "p")
|
|
(elpy-autopep8-fix-code))
|
|
((string-equal choice "r")
|
|
(elpy-refactor)))))
|
|
|
|
(provide 'elpy-refactor)
|
|
;;; elpy-refactor.el ends here
|