maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

subtree(users/wpcarro): docking briefcase at '24f5a642'

Browse source 
git-subtree-dir: users/wpcarro
git-subtree-mainline: 464bbcb15c
git-subtree-split: 24f5a642af
Change-Id: I6105b3762b79126b3488359c95978cadb3efa789
This commit is contained in:
Vincent Ambo 2021-12-14 01:51:19 +03:00
commit 019f8fd211
766 changed files with 175420 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

304
users/wpcarro/emacs/.emacs.d/vendor/reason-indent.el vendored Normal file
View file

@ -0,0 +1,304 @@
;;; reason-indent.el --- Indentation functions for ReasonML -*-lexical-binding: t-*-
;; Portions Copyright (c) 2015-present, Facebook, Inc. All rights reserved.
;;; Commentary:
;; Indentation functions for Reason.
;;; Code:
(defconst reason-re-ident "[[:word:][:multibyte:]_][[:word:][:multibyte:]_[:digit:]]*")
(defcustom reason-indent-offset 2
"Indent Reason code by this number of spaces."
:type 'integer
:group 'reason-mode
:safe #'integerp)
(defun reason-looking-back-str (str)
"Like `looking-back' but for fixed strings rather than regexps.
Works around some regexp slowness.
Argument STR string to search for."
(let ((len (length str)))
(and (> (point) len)
(equal str (buffer-substring-no-properties (- (point) len) (point))))))
(defun reason-paren-level ()
"Get the level of nesting inside parentheses."
(nth 0 (syntax-ppss)))
(defun reason-in-str-or-cmnt ()
"Return whether point is currently inside a string or a comment."
(nth 8 (syntax-ppss)))
(defun reason-rewind-past-str-cmnt ()
"Rewind past string or comment."
(goto-char (nth 8 (syntax-ppss))))
(defun reason-rewind-irrelevant ()
"Rewind past irrelevant characters (whitespace of inside comments)."
(interactive)
(let ((starting (point)))
(skip-chars-backward "[:space:]\n")
(if (reason-looking-back-str "*/") (backward-char))
(if (reason-in-str-or-cmnt)
(reason-rewind-past-str-cmnt))
(if (/= starting (point))
(reason-rewind-irrelevant))))
(defun reason-align-to-expr-after-brace ()
"Align the expression at point to the expression after the previous brace."
(save-excursion
(forward-char)
;; We don't want to indent out to the open bracket if the
;; open bracket ends the line
(when (not (looking-at "[[:blank:]]*\\(?://.*\\)?$"))
(when (looking-at "[[:space:]]")
(forward-word 1)
(backward-word 1))
(current-column))))
(defun reason-align-to-prev-expr ()
"Align the expression at point to the previous expression."
(let ((alignment (save-excursion
(forward-char)
;; We don't want to indent out to the open bracket if the
;; open bracket ends the line
(when (not (looking-at "[[:blank:]]*\\(?://.*\\)?$"))
(if (looking-at "[[:space:]]")
(progn
(forward-word 1)
(backward-word 1))
(backward-char))
(current-column)))))
(if (not alignment)
(save-excursion
(forward-char)
(forward-line)
(back-to-indentation)
(current-column))
alignment)))
;;; Start of a reason binding
(defvar reason-binding
(regexp-opt '("let" "type" "module" "fun")))
(defun reason-beginning-of-defun (&optional arg)
"Move backward to the beginning of the current defun.
With ARG, move backward multiple defuns. Negative ARG means
move forward.
This is written mainly to be used as `beginning-of-defun-function'.
Don't move to the beginning of the line. `beginning-of-defun',
which calls this, does that afterwards."
(interactive "p")
(re-search-backward (concat "^\\(" reason-binding "\\)\\_>")
nil 'move (or arg 1)))
(defun reason-end-of-defun ()
"Move forward to the next end of defun.
With argument, do it that many times.
Negative argument -N means move back to Nth preceding end of defun.
Assume that this is called after ‘beginning-of-defun’. So point is
at the beginning of the defun body.
This is written mainly to be used as `end-of-defun-function' for Reason."
(interactive)
;; Find the opening brace
(if (re-search-forward "[{]" nil t)
(progn
(goto-char (match-beginning 0))
;; Go to the closing brace
(condition-case nil
(forward-sexp)
(scan-error
;; The parentheses are unbalanced; instead of being unable to fontify, just jump to the end of the buffer
(goto-char (point-max)))))
;; There is no opening brace, so consider the whole buffer to be one "defun"
(goto-char (point-max))))
(defun reason-rewind-to-beginning-of-current-level-expr ()
"Rewind to the beginning of the expression on the current level of nesting."
(interactive)
(let ((current-level (reason-paren-level)))
(back-to-indentation)
(when (looking-at "=>")
(reason-rewind-irrelevant)
(back-to-indentation))
(while (> (reason-paren-level) current-level)
(backward-up-list)
(back-to-indentation))))
(defun reason-mode-indent-line ()
"Indent current line."
(interactive)
(let ((indent
(save-excursion
(back-to-indentation)
;; Point is now at beginning of current line
(let* ((level (reason-paren-level))
(baseline
;; Our "baseline" is one level out from the indentation of the expression
;; containing the innermost enclosing opening bracket. That
;; way if we are within a block that has a different
;; indentation than this mode would give it, we still indent
;; the inside of it correctly relative to the outside.
(if (= 0 level)
0
(save-excursion
(reason-rewind-irrelevant)
(if (save-excursion
(reason-rewind-to-beginning-of-current-level-expr)
(looking-at "<"))
(progn
(reason-rewind-to-beginning-of-current-level-expr)
(current-column))
(progn
(backward-up-list)
(reason-rewind-to-beginning-of-current-level-expr)
(cond
((looking-at "switch")
(current-column))
((looking-at "|")
(+ (current-column) (* reason-indent-offset 2)))
(t
(let ((current-level (reason-paren-level)))
(save-excursion
(while (and (= current-level (reason-paren-level))
(not (looking-at reason-binding)))
(reason-rewind-irrelevant)
(reason-rewind-to-beginning-of-current-level-expr))
(+ (current-column) reason-indent-offset)))))))))))
(cond
;; A function return type is indented to the corresponding function arguments
((looking-at "=>")
(+ baseline reason-indent-offset))
((reason-in-str-or-cmnt)
(cond
;; In the end of the block -- align with star
((looking-at "*/") (+ baseline 1))
;; Indent to the following shape:
;; /* abcd
;; * asdf
;; */
;;
((looking-at "*") (+ baseline 1))
;; Indent to the following shape:
;; /* abcd
;; asdf
;; */
;;
(t (+ baseline (+ reason-indent-offset 1)))))
((looking-at "</") (- baseline reason-indent-offset))
;; A closing brace is 1 level unindented
((looking-at "}\\|)\\|\\]")
(save-excursion
(reason-rewind-irrelevant)
(let ((jsx? (reason-looking-back-str ">")))
(backward-up-list)
(reason-rewind-to-beginning-of-current-level-expr)
(cond
((looking-at "switch") baseline)
(jsx? (current-column))
(t (- baseline reason-indent-offset))))))
;; Doc comments in /** style with leading * indent to line up the *s
((and (nth 4 (syntax-ppss)) (looking-at "*"))
(+ 1 baseline))
;; If we're in any other token-tree / sexp, then:
(t
(or
;; If we are inside a pair of braces, with something after the
;; open brace on the same line and ending with a comma, treat
;; it as fields and align them.
(when (> level 0)
(save-excursion
(reason-rewind-irrelevant)
(backward-up-list)
;; Point is now at the beginning of the containing set of braces
(reason-align-to-expr-after-brace)))
(progn
(back-to-indentation)
(cond ((looking-at (regexp-opt '("and" "type")))
baseline)
((save-excursion
(reason-rewind-irrelevant)
(= (point) 1))
baseline)
((save-excursion
(while (looking-at "|")
(reason-rewind-irrelevant)
(back-to-indentation))
(looking-at (regexp-opt '("type"))))
(+ baseline reason-indent-offset))
((looking-at "|\\|/[/*]")
baseline)
((and (> level 0)
(save-excursion
(reason-rewind-irrelevant)
(backward-up-list)
(reason-rewind-to-beginning-of-current-level-expr)
(looking-at "switch")))
(+ baseline reason-indent-offset))
((save-excursion
(reason-rewind-irrelevant)
(looking-back "[{;,\\[(]" (- (point) 2)))
baseline)
((and
(save-excursion
(reason-rewind-irrelevant)
(reason-rewind-to-beginning-of-current-level-expr)
(and (looking-at reason-binding)
(not (progn
(forward-sexp)
(forward-sexp)
(skip-chars-forward "[:space:]\n")
(looking-at "=")))))
(not (save-excursion
(skip-chars-backward "[:space:]\n")
(reason-looking-back-str "=>"))))
(save-excursion
(reason-rewind-irrelevant)
(backward-sexp)
(reason-align-to-prev-expr)))
((save-excursion
(reason-rewind-irrelevant)
(looking-back "<\/.*?>" (- (point) 30)))
baseline)
(t
(save-excursion
(reason-rewind-irrelevant)
(reason-rewind-to-beginning-of-current-level-expr)
(if (looking-at "|")
baseline
(+ baseline reason-indent-offset)))))
;; Point is now at the beginning of the current line
))))))))
(when indent
;; If we're at the beginning of the line (before or at the current
;; indentation), jump with the indentation change. Otherwise, save the
;; excursion so that adding the indentations will leave us at the
;; equivalent position within the line to where we were before.
(if (<= (current-column) (current-indentation))
(indent-line-to indent)
(save-excursion (indent-line-to indent))))))
(provide 'reason-indent)
;;; reason-indent.el ends here