le-python.el: Allow to chain method calls in Jython completion

* le-python.el (lispy-python-symbol-bnd): New defun.
(lispy-python-completion-at-point): Update.

* lispy-test.el (lispy-python-symbol-bnd): Add.

Suppose I want to end up with this:

    detector.getDetectorProperties ().getOwner ().getProbeProperties ()

Previously, completion would work only here:

    det|

and here:

    detector.get|

Now, completion also works here:

    detector.getDetectorProperties ().g|

 How it works:

    1. Store the longest complete method chain into a variable:

        # Assume no side effects for eval, lol.
        # Would be cool to statically derive the class.
        __t__ = detector.getDetectorProperties ()

    2. Request completions for e.g. "__t__.g".
    3. Remove "__t__" from the resulting completions.

Author: abo-abo

.gitignore

@@ -6,3 +6,4 @@
 \#*#
 .#*
 *~
+*$py.class

le-python.el

@@ -272,6 +272,23 @@ it at one time."
         nil
       (string< a b))))
 
+(defun lispy-python-symbol-bnd ()
+  (let ((bnd (or (bounds-of-thing-at-point 'symbol)
+                 (cons (point) (point)))))
+    (save-excursion
+     (goto-char (car bnd))
+     (while (progn
+              (skip-chars-backward " ")
+              (lispy-after-string-p "."))
+      (backward-char 1)
+      (skip-chars-backward " ")
+      (if (lispy-after-string-p ")")
+          (backward-sexp 2)
+          (backward-sexp)))
+     (skip-chars-forward " ")
+     (setcar bnd (point)))
+    bnd))
+
 (defun lispy-python-completion-at-point ()
   (cond ((looking-back "^\\(import\\|from\\) .*" (line-beginning-position))
          (let* ((line (buffer-substring-no-properties
@@ -300,18 +317,25 @@ it at one time."
                  (cl-sort (delete "./" (all-completions str #'read-file-name-internal))
                           #'lispy-dir-string<))))
         (t
-         (let ((comp (python-shell-completion-at-point (lispy--python-proc))))
-           (list (nth 0 comp)
-                 (nth 1 comp)
+         (let* ((bnd (lispy-python-symbol-bnd))
+                (str (buffer-substring-no-properties
+                      (car bnd) (cdr bnd))))
+           (when (string-match "\\()\\)[^)]*\\'" str)
+             (let ((expr (format "__t__ = %s" (substring str 0 (match-end 1)))))
+               (setq str (concat "__t__" (substring str (match-end 1))))
+               (cl-incf (car bnd) (match-end 1))
+               (lispy--eval-python expr t)))
+           (list (car bnd)
+                 (cdr bnd)
                  (mapcar (lambda (s)
-                           (if (string-match "(\\'" s)
-                               (substring s 0 (match-beginning 0))
-                             s))
-                         (all-completions
-                          (buffer-substring-no-properties
-                           (nth 0 comp)
-                           (nth 1 comp))
-                          (nth 2 comp))))))))
+                           (replace-regexp-in-string
+                            "__t__" ""
+                            (if (string-match "(\\'" s)
+                                (substring s 0 (match-beginning 0))
+                              s)))
+                         (python-shell-completion-get-completions
+                          (lispy--python-proc)
+                          nil str)))))))
 
 (defvar lispy--python-arg-key-re "\\`\\(\\(?:\\sw\\|\\s_\\)+\\) ?= ?\\(.*\\)\\'"
   "Constant regexp for matching function keyword spec.")

lispy-test.el

@@ -3035,6 +3035,16 @@ Insert KEY if there's no command."
                      (lispy--eval-python "print \"one\"\nprint \"two\"\nx = 2 + 1"))
                    "one\ntwo\n3"))))
 
+(ert-deftest lispy-python-symbol-bnd ()
+  (should (equal (lispy-with-python "def test_detector ():\n    detector.getChannelCount ().|"
+                                    (lispy--string-dwim
+                                     (lispy-python-symbol-bnd)))
+                 "detector.getChannelCount ()."))
+  (should (equal (lispy-with-python "def test_detector ():\n    detector.getDetectorProperties ().getOwner ().|"
+                                    (lispy--string-dwim
+                                     (lispy-python-symbol-bnd)))
+                 "detector.getDetectorProperties ().getOwner ().")))
+
 (provide 'lispy-test)
 
 ;;; lispy-test.el ends here