[nongnu] elpa/go-mode dbc9124 378/495: Move go-guru.el to top level

[ELPA Syncer]

branch: elpa/go-mode
commit dbc9124512e4154215414be27b1fff1664c20d83
Author: Dominik Honnef <dominik@honnef.co>
Commit: Dominik Honnef <dominik@honnef.co>

    Move go-guru.el to top level
---
 guru_import/cmd/guru/go-guru.el => go-guru.el |   0
 guru_import/cmd/oracle/oracle.el              | 230 --------------------------
 2 files changed, 230 deletions(-)

diff --git a/guru_import/cmd/guru/go-guru.el b/go-guru.el
similarity index 100%
rename from guru_import/cmd/guru/go-guru.el
rename to go-guru.el
diff --git a/guru_import/cmd/oracle/oracle.el b/guru_import/cmd/oracle/oracle.el
deleted file mode 100644
index 33c7409..0000000
--- a/guru_import/cmd/oracle/oracle.el
+++ /dev/null
@@ -1,230 +0,0 @@
-;;;
-;;; Integration of the Go 'oracle' analysis tool into Emacs.
-;;;
-;;; To install the Go oracle, run:
-;;; % export GOROOT=... GOPATH=...
-;;; % go get golang.org/x/tools/cmd/oracle
-;;; % mv $GOPATH/bin/oracle $GOROOT/bin/
-;;;
-;;; Load this file into Emacs and set go-oracle-scope to your
-;;; configuration. Then, find a file of Go source code, enable
-;;; go-oracle-mode, select an expression of interest, and press `C-c C-o d'
-;;; (for "describe") or run one of the other go-oracle-xxx commands.
-;;;
-;;; TODO(adonovan): simplify installation and configuration by making
-;;; oracle a subcommand of 'go tool'.
-
-(require 'compile)
-(require 'go-mode)
-(require 'cl)
-
-(defgroup go-oracle nil
-  "Options specific to the Go oracle."
-  :group 'go)
-
-(defcustom go-oracle-command "oracle"
-  "The Go oracle command."
-  :type 'string
-  :group 'go-oracle)
-
-(defcustom go-oracle-scope ""
-  "The scope of the analysis.  See `go-oracle-set-scope'."
-  :type 'string
-  :group 'go-oracle)
-
-(defvar go-oracle--scope-history
-  nil
-  "History of values supplied to `go-oracle-set-scope'.")
-
-;; Extend go-mode-map.
-(let ((m go-mode-map))
-  (define-key m (kbd "C-c C-o t") #'go-oracle-describe) ; t for type
-  (define-key m (kbd "C-c C-o f") #'go-oracle-freevars)
-  (define-key m (kbd "C-c C-o g") #'go-oracle-callgraph)
-  (define-key m (kbd "C-c C-o i") #'go-oracle-implements)
-  (define-key m (kbd "C-c C-o c") #'go-oracle-peers)  ; c for channel
-  (define-key m (kbd "C-c C-o r") #'go-oracle-referrers)
-  (define-key m (kbd "C-c C-o d") #'go-oracle-definition)
-  (define-key m (kbd "C-c C-o p") #'go-oracle-pointsto)
-  (define-key m (kbd "C-c C-o s") #'go-oracle-callstack)
-  (define-key m (kbd "C-c C-o <") #'go-oracle-callers)
-  (define-key m (kbd "C-c C-o >") #'go-oracle-callees)
-  (define-key m (kbd "<f5>") #'go-oracle-describe)
-  (define-key m (kbd "<f6>") #'go-oracle-referrers))
-
-;; TODO(dominikh): Rethink set-scope some. Setting it to a file is
-;; painful because it doesn't use find-file, and variables/~ aren't
-;; expanded. Setting it to an import path is somewhat painful because
-;; it doesn't make use of go-mode's import path completion. One option
-;; would be having two different functions, but then we can't
-;; automatically call it when no scope has been set. Also it wouldn't
-;; easily allow specifying more than one file/package.
-(defun go-oracle-set-scope ()
-  "Set the scope for the Go oracle, prompting the user to edit the
-previous scope.
-
-The scope specifies a set of arguments, separated by spaces.
-It may be:
-1) a set of packages whose main() functions will be analyzed.
-2) a list of *.go filenames; they will treated like as a single
-   package (see #3).
-3) a single package whose main() function and/or Test* functions
-   will be analyzed.
-
-In the common case, this is similar to the argument(s) you would
-specify to 'go build'."
-  (interactive)
-  (let ((scope (read-from-minibuffer "Go oracle scope: "
-                                     go-oracle-scope
-                                     nil
-                                     nil
-                                     'go-oracle--scope-history)))
-    (if (string-equal "" scope)
-        (error "You must specify a non-empty scope for the Go oracle"))
-    (setq go-oracle-scope scope)))
-
-(defun go-oracle--run (mode &optional need-scope)
-  "Run the Go oracle in the specified MODE, passing it the
-selected region of the current buffer.  If NEED-SCOPE, prompt for
-a scope if not already set.  Process the output to replace each
-file name with a small hyperlink.  Display the result."
-  (if (not buffer-file-name)
-      (error "Cannot use oracle on a buffer without a file name"))
-  ;; It's not sufficient to save a modified buffer since if
-  ;; gofmt-before-save is on the before-save-hook, saving will
-  ;; disturb the selected region.
-  (if (buffer-modified-p)
-      (error "Please save the buffer before invoking go-oracle"))
-  (and need-scope
-       (string-equal "" go-oracle-scope)
-       (go-oracle-set-scope))
-  (let* ((filename (file-truename buffer-file-name))
-         (posflag (if (use-region-p)
-                      (format "-pos=%s:#%d,#%d"
-                              filename
-                              (1- (go--position-bytes (region-beginning)))
-                              (1- (go--position-bytes (region-end))))
-                    (format "-pos=%s:#%d"
-                            filename
-                            (1- (position-bytes (point))))))
-         (env-vars (go-root-and-paths))
-         (goroot-env (concat "GOROOT=" (car env-vars)))
-         (gopath-env (concat "GOPATH=" (mapconcat #'identity (cdr env-vars) 
":"))))
-    (with-current-buffer (get-buffer-create "*go-oracle*")
-      (setq buffer-read-only nil)
-      (erase-buffer)
-      (insert "Go Oracle\n")
-      (let ((args (append (list go-oracle-command nil t nil posflag mode)
-                          (split-string go-oracle-scope " " t))))
-        ;; Log the command to *Messages*, for debugging.
-        (message "Command: %s:" args)
-        (message nil) ; clears/shrinks minibuffer
-
-        (message "Running oracle...")
-        ;; Use dynamic binding to modify/restore the environment
-        (let ((process-environment (list* goroot-env gopath-env 
process-environment)))
-            (apply #'call-process args)))
-      (insert "\n")
-      (compilation-mode)
-      (setq compilation-error-screen-columns nil)
-
-      ;; Hide the file/line info to save space.
-      ;; Replace each with a little widget.
-      ;; compilation-mode + this loop = slooow.
-      ;; TODO(adonovan): have oracle give us JSON
-      ;; and we'll do the markup directly.
-      (let ((buffer-read-only nil)
-            (p 1))
-        (while (not (null p))
-          (let ((np (compilation-next-single-property-change p 
'compilation-message)))
-            (if np
-                (when (equal (line-number-at-pos p) (line-number-at-pos np))
-                  ;; Using a fixed width greatly improves readability, so
-                  ;; if the filename is longer than 20, show 
".../last/17chars.go".
-                  ;; This usually includes the last segment of the package 
name.
-                  ;; Don't show the line or column number.
-                  (let* ((loc (buffer-substring p np)) ; 
"/home/foo/go/pkg/file.go:1:2-3:4"
-                         (i (search ":" loc)))
-                    (setq loc (cond
-                               ((null i)  "...")
-                               ((>= i 17) (concat "..." (substring loc (- i 
17) i)))
-                               (t         (substring loc 0 i))))
-                    ;; np is (typically) the space following ":"; consume it 
too.
-                    (put-text-property p np 'display (concat loc ":")))
-                  (goto-char np)
-                  (insert " ")
-                  (incf np))) ; so we don't get stuck (e.g. on a panic stack 
dump)
-            (setq p np)))
-        (message nil))
-
-      (let ((w (display-buffer (current-buffer))))
-        (balance-windows)
-        (shrink-window-if-larger-than-buffer w)
-        (set-window-point w (point-min))))))
-
-(defun go-oracle-callees ()
-  "Show possible callees of the function call at the current point."
-  (interactive)
-  (go-oracle--run "callees" t))
-
-(defun go-oracle-callers ()
-  "Show the set of callers of the function containing the current point."
-  (interactive)
-  (go-oracle--run "callers" t))
-
-(defun go-oracle-callgraph ()
-  "Show the callgraph of the current program."
-  (interactive)
-  (go-oracle--run "callgraph" t))
-
-(defun go-oracle-callstack ()
-  "Show an arbitrary path from a root of the call graph to the
-function containing the current point."
-  (interactive)
-  (go-oracle--run "callstack" t))
-
-(defun go-oracle-definition ()
-  "Show the definition of the selected identifier."
-  (interactive)
-  (go-oracle--run "definition"))
-
-(defun go-oracle-describe ()
-  "Describe the selected syntax, its kind, type and methods."
-  (interactive)
-  (go-oracle--run "describe"))
-
-(defun go-oracle-pointsto ()
-  "Show what the selected expression points to."
-  (interactive)
-  (go-oracle--run "pointsto" t))
-
-(defun go-oracle-implements ()
-  "Describe the 'implements' relation for types in the package
-containing the current point."
-  (interactive)
-  (go-oracle--run "implements"))
-
-(defun go-oracle-freevars ()
-  "Enumerate the free variables of the current selection."
-  (interactive)
-  (go-oracle--run "freevars"))
-
-(defun go-oracle-peers ()
-  "Enumerate the set of possible corresponding sends/receives for
-this channel receive/send operation."
-  (interactive)
-  (go-oracle--run "peers" t))
-
-(defun go-oracle-referrers ()
-  "Enumerate all references to the object denoted by the selected
-identifier."
-  (interactive)
-  (go-oracle--run "referrers"))
-
-(defun go-oracle-whicherrs ()
-  "Show globals, constants and types to which the selected
-expression (of type 'error') may refer."
-  (interactive)
-  (go-oracle--run "whicherrs" t))
-
-(provide 'go-oracle)