(defun ruby-smie--redundant-do-p (&optional skip)
(save-excursion
- (if skip (backward-word-strictly 1))
+ (if skip (backward-word 1))
(member (nth 2 (smie-backward-sexp ";")) '("while" "until" "for"))))
(defun ruby-smie--opening-pipe-p ()
(setq tok (concat "." tok)))
(cond
((member tok '("unless" "if" "while" "until"))
- (if (save-excursion (forward-word-strictly -1) (ruby-smie--bosp))
+ (if (save-excursion (forward-word -1) (ruby-smie--bosp))
tok "iuwu-mod"))
((string-match-p "\\`|[*&]?\\'" tok)
(forward-char (- 1 (length tok)))
((equal tok "do")
(cond
((not (ruby-smie--redundant-do-p)) tok)
- ((> (save-excursion (forward-word-strictly 1)
+ ((> (save-excursion (forward-word 1)
(forward-comment (point-max)) (point))
(line-end-position))
(ruby-smie--backward-token)) ;Fully redundant.
;; us to do better.
(when (not (memq (car (syntax-after (1- (point)))) '(2 3 6 10)))
(or (not (memq (char-before) '(?\s ?\t)))
- (ignore (forward-word-strictly -1))
+ (ignore (forward-word -1))
(eq (char-before) ?_)
(not (looking-at ruby-singleton-class-re))))))
((let ((s (ruby-parse-region (point) ruby-indent-point)))
(and (nth 2 s) (> (nth 2 s) 0)
(or (goto-char (cdr (nth 1 s))) t)))
- (forward-word-strictly -1)
+ (forward-word -1)
(setq indent (ruby-indent-size (current-column)
(nth 2 state))))
(t
(if (null (cdr (nth 1 state)))
(error "Invalid nesting"))
(goto-char (cdr (nth 1 state)))
- (forward-word-strictly -1) ; skip back a keyword
+ (forward-word -1) ; skip back a keyword
(setq begin (point))
(cond
((looking-at "do\\>[^_]") ; iter block is a special case
(forward-char -1)
(not (looking-at "{")))
(progn
- (forward-word-strictly -1)
+ (forward-word -1)
(not (looking-at "do\\>[^_]")))))
(t t))))
(not (eq ?, c))
(not (eq (char-before (point)) ?.))
(not (eq (char-before (point)) ?:)))
(ruby-end-of-block)
- (forward-word-strictly 1))
+ (forward-word 1))
((looking-at "\\(\\$\\|@@?\\)?\\sw")
(while (progn
- (while (progn (forward-word-strictly 1)
- (looking-at "_")))
+ (while (progn (forward-word 1) (looking-at "_")))
(cond ((looking-at "::") (forward-char 2) t)
((> (skip-chars-forward ".") 0))
((looking-at "\\?\\|!\\(=[~=>]\\|[^~=]\\)")
(skip-chars-forward "<"))
(not expr))))
(setq i (1- i)))
- ((error) (forward-word-strictly 1)))
+ ((error) (forward-word 1)))
i))))
(defun ruby-backward-sexp (&optional arg)
((looking-at "\\s(") nil)
(t
(forward-char 1)
- (while (progn (forward-word-strictly -1)
+ (while (progn (forward-word -1)
(pcase (char-before)
(`?_ t)
(`?. (forward-char -1) t)