~a-roehler/python-mode/components-python-mode

;;; python-components-up-down.el -- Searching up/downwards in buffer -*- lexical-binding: t; -*- 

;; Copyright (C) 2015-2016  Andreas Röhler

;; Author: Andreas Röhler <andreas.roehler@online.de>
;; Keywords: languages, convenience

;; 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 is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.

;;; Code:


(defun py-up-statement ()
  "Go to the beginning of next statement upwards in buffer.

Return position if statement found, nil otherwise. "
  (interactive)
  (let (erg)
    (if (py--beginning-of-statement-p)
	(setq erg (py-backward-statement))
      (setq erg (and (py-backward-statement) (py-backward-statement))))
    (when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
    erg))

(defun py-down-statement ()
  "Go to the beginning of next statement downwards in buffer.

Return position if statement found, nil otherwise. "
  (interactive)
  (let* ((orig (point))
	 erg)
    (cond ((py--end-of-statement-p)
	   (setq erg (and (py-forward-statement) (py-backward-statement))))
	  ((setq erg (< orig (progn (py-forward-statement) (py-backward-statement))))
	   (point))
	  (t (setq erg (and (py-forward-statement) (py-forward-statement)(py-backward-statement)))))
    (when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
    erg))

(defun py-up-base (regexp &optional indent orig decorator bol repeat)
  "Go to the beginning of next form upwards in buffer.

Return position if form found, nil otherwise.
REGEXP is a quoted symbol "
  (unless (bobp)
    (let* ((orig (or orig (point)))
	   (repeat (or (and repeat (1+ repeat)) 999))
	   erg name command)
      (if (< py-max-specpdl-size repeat)
	  (error "`py-up-base' reached loops max.")
	(if indent
	    (progn
	      (while (and (re-search-backward (symbol-value regexp) nil 'move 1)
			  (or (nth 8 (parse-partial-sexp (point-min) (point)))
			      (<= indent (current-indentation))))))
	  (unless (py--beginning-of-statement-p)
	    (py-backward-statement))
	  (if (looking-at (symbol-value regexp))
	      (py-up-base regexp (current-indentation) orig decorator bol repeat)
	    (setq name (symbol-name regexp))
	    (setq command (intern-soft (concat "py-backward-" (substring name (string-match "minor\\|block\\|def\\|class" name) (string-match "-re" name)))))
	    (funcall command)
	    (py-up-base regexp (current-indentation) orig decorator bol repeat)))
	(when bol (beginning-of-line))
	(and (looking-at (symbol-value regexp)) (< (point) orig) (setq erg (point)))
	(when py-verbose-p (message "%s" erg))
	erg))))

(defun py-down-base (regexp &optional orig indent decorator bol)
  "Go to the beginning of next form below in buffer.

Return position if form found, nil otherwise.
Expects a quoted symbol 'REGEXP"
  (unless (eobp)
    (let* ((name (substring (symbol-name regexp) 3 -3))
	   (p-command (car (read-from-string (concat "py--beginning-of-" name "-p"))))
	   (backward-command (car (read-from-string (concat "py-backward-" name))))
	   (up-command (car (read-from-string (concat "py-up-" name))))
	   ;; (down-command (car (read-from-string (concat "py-down-" name))))
           (forward-command (car (read-from-string (concat "py-forward-" name))))
           erg done start)
      (if (funcall p-command)
	  (setq indent (current-indentation))
	(save-excursion
	  (cond
	   ((and indent decorator bol)
	    (funcall backward-command indent decorator bol))
	   ((and indent decorator)
	    (funcall backward-command indent decorator))
	   (t (funcall backward-command indent)))
	  (setq indent (current-indentation))
	  (setq start (point))))
      ;; (setq done (funcall forward-command indent decorator bol))
      (while (and (not done)
		  (py-down-statement)
		  (<= indent (current-indentation))
		  (when (looking-at (symbol-value regexp))
		    (setq done (point)))))
      (when done
	(when bol (beginning-of-line))
	(setq erg (point)))
      (unless done
	(goto-char orig)
	(or
	 (if
	     (and
	      (funcall up-command)
	      ;; up should not result to backward
	      (not (eq (point) start))
	      (funcall forward-command decorator bol)
	      (< orig (point))
	      (setq erg (point)))
	     (when bol (setq erg (py--beginning-of-line-form erg)))
	   (goto-char (point-max)))))
      (when py-verbose-p (message "%s" erg))
      erg)))

(defalias 'py-block-up 'py-up-block)
(defun py-up-block (&optional indent decorator bol)
  "Go to the beginning of next block upwards in buffer.

Return position if block found, nil otherwise. "
  (interactive)
  (py-up-base 'py-extended-block-or-clause-re indent (point) decorator bol))

(defalias 'py-class-up 'py-up-class)
(defun py-up-class (&optional indent decorator bol)
  "Go to the beginning of next class upwards in buffer.

Return position if class found, nil otherwise. "
  (interactive)
  (py-up-base 'py-class-re indent (point) decorator bol))

(defalias 'py-def-up 'py-up-def)
(defun py-up-def (&optional indent decorator bol)
  "Go to the beginning of next def upwards in buffer.

Return position if def found, nil otherwise. "
  (interactive)
  (py-up-base 'py-def-re indent (point) decorator bol))

(defalias 'py-def-or-class-up 'py-up-def-or-class)
(defun py-up-def-or-class (&optional indent decorator bol)
  "Go to the beginning of next def-or-class upwards in buffer.

Return position if def-or-class found, nil otherwise. "
  (interactive)
  (py-up-base 'py-def-or-class-re indent (point) decorator bol))

(defalias 'py-minor-block-up 'py-up-minor-block)
(defun py-up-minor-block (&optional indent decorator bol)
  "Go to the beginning of next minor-block upwards in buffer.

Return position if minor-block found, nil otherwise. "
  (interactive)
  (py-up-base 'py-extended-block-or-clause-re indent (point) decorator bol))

(defalias 'py-block-down 'py-down-block)
(defun py-down-block (&optional orig indent decorator bol)
  "Go to the beginning of next block below in buffer.

Return position if block found, nil otherwise. "
  (interactive)
  (py-down-base 'py-block-re (or orig (point)) indent decorator bol))

(defalias 'py-class-down 'py-down-class)
(defun py-down-class (&optional orig indent decorator bol)
  "Go to the beginning of next class below in buffer.

Return position if class found, nil otherwise. "
  (interactive)
  (py-down-base 'py-class-re (or orig (point)) indent decorator bol))

(defalias 'py-def-down 'py-down-def)
(defun py-down-def (&optional orig indent decorator bol)
  "Go to the beginning of next def below in buffer.

Return position if def found, nil otherwise. "
  (interactive)
  (py-down-base 'py-def-re (or orig (point)) indent decorator bol))

(defalias 'py-def-or-class-down 'py-down-def-or-class)
(defun py-down-def-or-class (&optional orig indent decorator bol)
  "Go to the beginning of next def-or-class below in buffer.

Return position if def-or-class found, nil otherwise. "
  (interactive)
  (py-down-base 'py-def-or-class-re (or orig (point)) indent decorator bol))

(defalias 'py-minor-block-down 'py-down-minor-block)
(defun py-down-minor-block (&optional orig indent decorator bol)
  "Go to the beginning of next minor-block below in buffer.

Return position if minor-block found, nil otherwise. "
  (interactive)
  (py-down-base 'py-minor-block-re (or orig (point)) indent decorator bol))

(defun py-up-block-bol (&optional indent decorator)
  "Go to the beginning of next block upwards in buffer.

Go to beginning of line.
Return position if block found, nil otherwise. "
  (interactive)
  (py-up-base 'py-block-re indent (point) decorator t))

(defun py-up-class-bol (&optional indent decorator)
  "Go to the beginning of next class upwards in buffer.

Go to beginning of line.
Return position if class found, nil otherwise. "
  (interactive)
  (py-up-base 'py-class-re indent (point) decorator t))

(defun py-up-def-bol (&optional indent decorator)
  "Go to the beginning of next def upwards in buffer.

Go to beginning of line.
Return position if def found, nil otherwise. "
  (interactive)
  (py-up-base 'py-def-re indent (point) decorator t))

(defun py-up-def-or-class-bol (&optional indent decorator)
  "Go to the beginning of next def-or-class upwards in buffer.

Go to beginning of line.
Return position if def-or-class found, nil otherwise. "
  (interactive)
  (py-up-base 'py-def-or-class-re indent (point) decorator t))

(defun py-up-minor-block-bol (&optional indent decorator)
  "Go to the beginning of next minor-block upwards in buffer.

Go to beginning of line.
Return position if minor-block found, nil otherwise. "
  (interactive)
  (py-up-base 'py-minor-block-re indent (point) decorator t))

(defun py-down-block-bol (&optional orig indent decorator bol)
  "Go to the beginning of next block below in buffer.

Go to beginning of line
Return position if block found, nil otherwise "
  (interactive)
  (py-down-base 'py-block-re (or orig (point)) indent decorator (or bol t)))

(defun py-down-class-bol (&optional orig indent decorator bol)
  "Go to the beginning of next class below in buffer.

Go to beginning of line
Return position if class found, nil otherwise "
  (interactive)
  (py-down-base 'py-class-re (or orig (point)) indent decorator (or bol t)))

(defun py-down-def-bol (&optional orig indent decorator bol)
  "Go to the beginning of next def below in buffer.

Go to beginning of line
Return position if def found, nil otherwise "
  (interactive)
  (py-down-base 'py-def-re (or orig (point)) indent decorator (or bol t)))

(defun py-down-def-or-class-bol (&optional orig indent decorator bol)
  "Go to the beginning of next def-or-class below in buffer.

Go to beginning of line
Return position if def-or-class found, nil otherwise "
  (interactive)
  (py-down-base 'py-def-or-class-re (or orig (point)) indent decorator (or bol t)))

(defun py-down-minor-block-bol (&optional orig indent decorator bol)
  "Go to the beginning of next minor-block below in buffer.

Go to beginning of line
Return position if minor-block found, nil otherwise "
  (interactive)
  (py-down-base 'py-minor-block-re (or orig (point)) indent decorator (or bol t)))

;; python-components-up-down.el ends here
(provide 'python-components-up-down)