1027 lines
30 KiB
EmacsLisp
1027 lines
30 KiB
EmacsLisp
;;; ruby-mode-tests.el --- Test suite for ruby-mode -*- lexical-binding:t -*-
|
|
|
|
;; Copyright (C) 2012-2024 Free Software Foundation, Inc.
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
;; GNU Emacs 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.
|
|
|
|
;; GNU Emacs 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 GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
;;; Commentary:
|
|
|
|
;;; Code:
|
|
|
|
(require 'ert)
|
|
(require 'ert-x)
|
|
(require 'ruby-mode)
|
|
|
|
(defmacro ruby-with-temp-buffer (contents &rest body)
|
|
(declare (indent 1) (debug t))
|
|
`(with-temp-buffer
|
|
(insert ,contents)
|
|
(ruby-mode)
|
|
,@body))
|
|
|
|
(defmacro ruby-with-temp-file (contents &rest body)
|
|
`(ruby-with-temp-buffer ,contents
|
|
(set-visited-file-name "ruby-mode-tests")
|
|
,@body
|
|
(set-buffer-modified-p nil)
|
|
(delete-file buffer-file-name)))
|
|
|
|
(defun ruby-should-indent (content column)
|
|
"Assert indentation COLUMN on the last line of CONTENT."
|
|
(ruby-with-temp-buffer content
|
|
(indent-according-to-mode)
|
|
(should (= (current-indentation) column))))
|
|
|
|
(defun ruby-should-indent-buffer (expected content)
|
|
"Assert that CONTENT turns into EXPECTED after the buffer is re-indented.
|
|
|
|
The whitespace before and including \"|\" on each line is removed."
|
|
(ruby-with-temp-buffer (ruby-test-string content)
|
|
(indent-region (point-min) (point-max))
|
|
(should (string= (ruby-test-string expected) (buffer-string)))))
|
|
|
|
(defun ruby-test-string (s &rest args)
|
|
(apply 'format (replace-regexp-in-string "^[ \t]*|" "" s) args))
|
|
|
|
(defun ruby-assert-state (content index value &optional point)
|
|
"Assert syntax state values at the end of CONTENT.
|
|
|
|
VALUES-PLIST is a list with alternating index and value elements."
|
|
(ruby-with-temp-buffer content
|
|
(when point (goto-char point))
|
|
(syntax-propertize (point))
|
|
(should (eq (nth index
|
|
(parse-partial-sexp (point-min) (point)))
|
|
value))))
|
|
|
|
(defun ruby-assert-face (content pos face)
|
|
(ruby-with-temp-buffer content
|
|
(font-lock-ensure nil nil)
|
|
(should (eq face (get-text-property pos 'face)))))
|
|
|
|
(ert-deftest ruby-indent-after-symbol-made-from-string-interpolation ()
|
|
"It can indent the line after symbol made using string interpolation."
|
|
(ruby-should-indent "def foo(suffix)\n :\"bar#{suffix}\"\n"
|
|
ruby-indent-level))
|
|
|
|
(ert-deftest ruby-indent-after-js-style-symbol-with-block-beg-name ()
|
|
"JS-style hash symbol can have keyword name."
|
|
(ruby-should-indent "link_to \"home\", home_path, class: \"foo\"\n" 0))
|
|
|
|
(ert-deftest ruby-discern-singleton-class-from-heredoc ()
|
|
(ruby-assert-state "foo <<asd\n" 3 ?\n)
|
|
(ruby-assert-state "class <<asd\n" 3 nil))
|
|
|
|
(ert-deftest ruby-heredoc-font-lock ()
|
|
(let ((s "foo <<eos.gsub('^ *', '')"))
|
|
(ruby-assert-face s 9 font-lock-string-face)
|
|
(ruby-assert-face s 10 nil)))
|
|
|
|
(ert-deftest ruby-singleton-class-no-heredoc-font-lock ()
|
|
(ruby-assert-face "class<<a" 8 nil))
|
|
|
|
(ert-deftest ruby-heredoc-highlights-interpolations ()
|
|
(ruby-assert-face "s = <<EOS\n #{foo}\nEOS" 15 font-lock-variable-name-face))
|
|
|
|
(ert-deftest ruby-no-heredoc-inside-quotes ()
|
|
(ruby-assert-state "\"<<\", \"\",\nfoo" 3 nil))
|
|
|
|
(ert-deftest ruby-no-heredoc-left-shift ()
|
|
;; We can't really detect the left shift operator (like in similar
|
|
;; cases, it depends on the type of foo), so we just require for <<
|
|
;; to be preceded by a character from a known set.
|
|
(ruby-assert-state "foo(a<<b)" 3 nil))
|
|
|
|
(ert-deftest ruby-no-heredoc-class-self ()
|
|
(ruby-assert-state "class <<self\nend" 3 nil))
|
|
|
|
(ert-deftest ruby-exit!-font-lock ()
|
|
(ruby-assert-face "exit!" 5 font-lock-builtin-face))
|
|
|
|
(ert-deftest ruby-deep-indent ()
|
|
(let ((ruby-deep-arglist nil)
|
|
(ruby-deep-indent-paren '(?\( ?\{ ?\[ ?\] t)))
|
|
(ruby-should-indent "foo = [1,\n2" 7)
|
|
(ruby-should-indent "foo = {a: b,\nc: d" 7)
|
|
(ruby-should-indent "foo(a,\nb" 4)))
|
|
|
|
(ert-deftest ruby-deep-indent-disabled ()
|
|
(let ((ruby-deep-arglist nil)
|
|
(ruby-deep-indent-paren nil))
|
|
(ruby-should-indent "foo = [\n1" ruby-indent-level)
|
|
(ruby-should-indent "foo = {\na: b" ruby-indent-level)
|
|
(ruby-should-indent "foo(\na" ruby-indent-level)))
|
|
|
|
(ert-deftest ruby-indent-after-keyword-in-a-string ()
|
|
(ruby-should-indent "a = \"abc\nif\"\n " 0)
|
|
(ruby-should-indent "a = %w[abc\n def]\n " 0)
|
|
(ruby-should-indent "a = \"abc\n def\"\n " 0))
|
|
|
|
(ert-deftest ruby-regexp-doesnt-start-in-string ()
|
|
(ruby-assert-state "'(/', /\d+/" 3 nil))
|
|
|
|
(ert-deftest ruby-regexp-starts-after-string ()
|
|
(ruby-assert-state "'(/', /\d+/" 3 ?/ 8))
|
|
|
|
(ert-deftest ruby-regexp-interpolation-is-highlighted ()
|
|
(ruby-assert-face "/#{foobs}/" 4 font-lock-variable-name-face))
|
|
|
|
(ert-deftest ruby-regexp-skips-over-interpolation ()
|
|
(ruby-assert-state "/#{foobs.join('/')}/" 3 nil))
|
|
|
|
(ert-deftest ruby-regexp-continues-till-end-when-unclosed ()
|
|
(ruby-assert-state "/bars" 3 ?/))
|
|
|
|
(ert-deftest ruby-regexp-can-be-multiline ()
|
|
(ruby-assert-state "/bars\ntees # toots \nfoos/" 3 nil))
|
|
|
|
(ert-deftest ruby-slash-symbol-is-not-mistaken-for-regexp ()
|
|
(ruby-assert-state ":/" 3 nil))
|
|
|
|
(ert-deftest ruby-slash-char-literal-is-not-mistaken-for-regexp ()
|
|
(ruby-assert-state "?/" 3 nil))
|
|
|
|
(ert-deftest ruby-regexp-is-not-mistaken-for-slash-symbol ()
|
|
(ruby-assert-state "x = /foo:/" 3 nil))
|
|
|
|
(ert-deftest ruby-slash-not-regexp-when-surrounded-by-spaces ()
|
|
(ruby-assert-state "x = index / 3" 3 nil))
|
|
|
|
(ert-deftest ruby-slash-not-regexp-when-no-spaces ()
|
|
(ruby-assert-state "x = index/3" 3 nil))
|
|
|
|
(ert-deftest ruby-regexp-not-division-when-only-space-before ()
|
|
(ruby-assert-state "x = foo_index /3" 3 ?/))
|
|
|
|
(ert-deftest ruby-slash-not-regexp-when-only-space-after ()
|
|
(ruby-assert-state "x = index/ 3" 3 nil))
|
|
|
|
(ert-deftest ruby-indent-simple ()
|
|
(ruby-should-indent-buffer
|
|
"if foo
|
|
| bar
|
|
|end
|
|
|zot
|
|
|"
|
|
"if foo
|
|
|bar
|
|
| end
|
|
| zot
|
|
|"))
|
|
|
|
(ert-deftest ruby-indent-keyword-label ()
|
|
(ruby-should-indent-buffer
|
|
"bar(class: XXX) do
|
|
| foo
|
|
|end
|
|
|bar
|
|
|"
|
|
"bar(class: XXX) do
|
|
| foo
|
|
| end
|
|
| bar
|
|
|"))
|
|
|
|
(ert-deftest ruby-indent-method-with-question-mark ()
|
|
(ruby-should-indent-buffer
|
|
"if x.is_a?(XXX)
|
|
| foo
|
|
|end
|
|
|"
|
|
"if x.is_a?(XXX)
|
|
| foo
|
|
| end
|
|
|"))
|
|
|
|
(ert-deftest ruby-indent-expr-in-regexp ()
|
|
(ruby-should-indent-buffer
|
|
"if /#{foo}/ =~ s
|
|
| x = 1
|
|
|end
|
|
|"
|
|
"if /#{foo}/ =~ s
|
|
| x = 1
|
|
| end
|
|
|"))
|
|
|
|
(ert-deftest ruby-indent-singleton-class ()
|
|
(ruby-should-indent-buffer
|
|
"class<<bar
|
|
| foo
|
|
|end
|
|
|"
|
|
"class<<bar
|
|
|foo
|
|
| end
|
|
|"))
|
|
|
|
(ert-deftest ruby-indent-inside-heredoc-after-operator ()
|
|
(ruby-should-indent-buffer
|
|
"b=<<eos
|
|
| 42"
|
|
"b=<<eos
|
|
| 42"))
|
|
|
|
(ert-deftest ruby-indent-inside-heredoc-after-space ()
|
|
(ruby-should-indent-buffer
|
|
"foo <<eos.gsub(' ', '*')
|
|
| 42"
|
|
"foo <<eos.gsub(' ', '*')
|
|
| 42"))
|
|
|
|
(ert-deftest ruby-indent-array-literal ()
|
|
(let ((ruby-deep-indent-paren nil))
|
|
(ruby-should-indent-buffer
|
|
"foo = [
|
|
| bar
|
|
|]
|
|
|"
|
|
"foo = [
|
|
| bar
|
|
| ]
|
|
|"))
|
|
(ruby-should-indent-buffer
|
|
"foo do
|
|
| [bar]
|
|
|end
|
|
|"
|
|
"foo do
|
|
|[bar]
|
|
| end
|
|
|"))
|
|
|
|
(ert-deftest ruby-indent-begin-end ()
|
|
(ruby-should-indent-buffer
|
|
"begin
|
|
| a[b]
|
|
|end
|
|
|"
|
|
"begin
|
|
| a[b]
|
|
| end
|
|
|"))
|
|
|
|
(ert-deftest ruby-indent-array-after-paren-and-space ()
|
|
(ruby-should-indent-buffer
|
|
"class A
|
|
| def foo
|
|
| foo( [])
|
|
| end
|
|
|end
|
|
|"
|
|
"class A
|
|
| def foo
|
|
|foo( [])
|
|
|end
|
|
| end
|
|
|"))
|
|
|
|
(ert-deftest ruby-indent-after-block-in-continued-expression ()
|
|
(ruby-should-indent-buffer
|
|
"var =
|
|
| begin
|
|
| val
|
|
| end
|
|
|statement"
|
|
"var =
|
|
|begin
|
|
|val
|
|
|end
|
|
|statement"))
|
|
|
|
(ert-deftest ruby-indent-spread-args-in-parens ()
|
|
(let ((ruby-deep-indent-paren '(?\()))
|
|
(ruby-should-indent-buffer
|
|
"foo(1,
|
|
| 2,
|
|
| 3)
|
|
|"
|
|
"foo(1,
|
|
| 2,
|
|
| 3)
|
|
|")))
|
|
|
|
(ert-deftest ruby-align-to-stmt-keywords-t ()
|
|
(let ((ruby-align-to-stmt-keywords t))
|
|
(ruby-should-indent-buffer
|
|
"foo = if bar?
|
|
| 1
|
|
|else
|
|
| 2
|
|
|end
|
|
|
|
|
|foo || begin
|
|
| bar
|
|
|end
|
|
|
|
|
|foo ||
|
|
| begin
|
|
| bar
|
|
| end
|
|
|"
|
|
"foo = if bar?
|
|
| 1
|
|
|else
|
|
| 2
|
|
| end
|
|
|
|
|
| foo || begin
|
|
| bar
|
|
|end
|
|
|
|
|
| foo ||
|
|
| begin
|
|
|bar
|
|
| end
|
|
|")
|
|
))
|
|
|
|
(ert-deftest ruby-align-to-stmt-keywords-case ()
|
|
(let ((ruby-align-to-stmt-keywords '(case)))
|
|
(ruby-should-indent-buffer
|
|
"b = case a
|
|
|when 13
|
|
| 6
|
|
|else
|
|
| 42
|
|
|end"
|
|
"b = case a
|
|
| when 13
|
|
| 6
|
|
| else
|
|
| 42
|
|
| end")))
|
|
|
|
(ert-deftest ruby-align-chained-calls ()
|
|
(let ((ruby-align-chained-calls t))
|
|
(ruby-should-indent-buffer
|
|
"one.two.three
|
|
| .four
|
|
|
|
|
|my_array.select { |str| str.size > 5 }
|
|
| .map { |str| str.downcase }"
|
|
"one.two.three
|
|
| .four
|
|
|
|
|
|my_array.select { |str| str.size > 5 }
|
|
| .map { |str| str.downcase }")))
|
|
|
|
(ert-deftest ruby-move-to-block-stops-at-indentation ()
|
|
(ruby-with-temp-buffer "def f\nend"
|
|
(beginning-of-line)
|
|
(ruby-move-to-block -1)
|
|
(should (looking-at "^def"))))
|
|
|
|
(ert-deftest ruby-toggle-block-to-do-end ()
|
|
(ruby-with-temp-buffer "foo {|b|\n}"
|
|
(beginning-of-line)
|
|
(ruby-toggle-block)
|
|
(should (string= "foo do |b|\nend" (buffer-string))))
|
|
(ruby-with-temp-buffer "foo {|b| b }"
|
|
(beginning-of-line)
|
|
(ruby-toggle-block)
|
|
(should (string= "foo do |b|\n b\nend" (buffer-string)))))
|
|
|
|
(ert-deftest ruby-toggle-block-to-brace ()
|
|
(let ((pairs '((17 . "foo { |b| b + 2 }")
|
|
(16 . "foo { |b|\n b + 2\n}"))))
|
|
(dolist (pair pairs)
|
|
(with-temp-buffer
|
|
(let ((fill-column (car pair)))
|
|
(insert "foo do |b|\n b + 2\nend")
|
|
(ruby-mode)
|
|
(beginning-of-line)
|
|
(ruby-toggle-block)
|
|
(should (string= (cdr pair) (buffer-string))))))))
|
|
|
|
(ert-deftest ruby-toggle-block-to-multiline ()
|
|
(ruby-with-temp-buffer "foo {|b| b + 1}"
|
|
(beginning-of-line)
|
|
(ruby-toggle-block)
|
|
(should (string= "foo do |b|\n b + 1\nend" (buffer-string)))))
|
|
|
|
(ert-deftest ruby-toggle-block-with-interpolation ()
|
|
(ruby-with-temp-buffer "foo do\n \"#{bar}\"\nend"
|
|
(beginning-of-line)
|
|
(ruby-toggle-block)
|
|
(should (string= "foo { \"#{bar}\" }" (buffer-string)))))
|
|
|
|
(ert-deftest ruby-toggle-block-to-brace-no-space ()
|
|
(ruby-with-temp-buffer "foo do |b|\n b + 2\nend"
|
|
(beginning-of-line)
|
|
(let (ruby-toggle-block-space-before-parameters)
|
|
(ruby-toggle-block))
|
|
(should (string= "foo {|b| b + 2 }" (buffer-string)))))
|
|
|
|
(ert-deftest ruby-recognize-symbols-starting-with-at-character ()
|
|
(ruby-assert-face ":@abc" 3 font-lock-constant-face))
|
|
|
|
(ert-deftest ruby-hash-character-not-interpolation ()
|
|
(ruby-assert-face "\"This is #{interpolation}\"" 15
|
|
font-lock-variable-name-face)
|
|
(ruby-assert-face "\"This is \\#{no interpolation} despite the #\""
|
|
15 font-lock-string-face)
|
|
(ruby-assert-face "\n#@comment, not ruby code" 5 font-lock-comment-face)
|
|
(ruby-assert-state "\n#@comment, not ruby code" 4 t)
|
|
(ruby-assert-face "# A comment cannot have #{an interpolation} in it"
|
|
30 font-lock-comment-face)
|
|
(ruby-assert-face "# #{comment}\n \"#{interpolation}\"" 16
|
|
font-lock-variable-name-face))
|
|
|
|
(ert-deftest ruby-interpolation-suppresses-quotes-inside ()
|
|
(let ((s "\"<ul><li>#{@files.join(\"</li><li>\")}</li></ul>\""))
|
|
(ruby-assert-state s 8 nil)
|
|
(ruby-assert-face s 9 font-lock-string-face)
|
|
(ruby-assert-face s 10 font-lock-variable-name-face)
|
|
(ruby-assert-face s 41 font-lock-string-face)))
|
|
|
|
(ert-deftest ruby-interpolation-suppresses-one-double-quote ()
|
|
(let ((s "\"foo#{'\"'}\""))
|
|
(ruby-assert-state s 8 nil)
|
|
(ruby-assert-face s 8 font-lock-variable-name-face)
|
|
(ruby-assert-face s 11 font-lock-string-face)))
|
|
|
|
(ert-deftest ruby-interpolation-suppresses-one-backtick ()
|
|
(let ((s "`as#{'`'}das`"))
|
|
(ruby-assert-state s 8 nil)))
|
|
|
|
(ert-deftest ruby-interpolation-keeps-non-quote-syntax ()
|
|
(let ((s "\"foo#{baz.tee}bar\""))
|
|
(ruby-with-temp-buffer s
|
|
(goto-char (point-min))
|
|
(ruby-mode)
|
|
(syntax-propertize (point-max))
|
|
(search-forward "tee")
|
|
(should (string= (thing-at-point 'symbol) "tee")))))
|
|
|
|
(ert-deftest ruby-interpolation-inside-percent-literal ()
|
|
(let ((s "%( #{boo} )"))
|
|
(ruby-assert-face s 1 font-lock-string-face)
|
|
(ruby-assert-face s 4 font-lock-variable-name-face)
|
|
(ruby-assert-face s 10 font-lock-string-face)
|
|
(ruby-assert-state s 8 nil)))
|
|
|
|
(ert-deftest ruby-interpolation-inside-percent-literal-with-paren ()
|
|
:expected-result :failed
|
|
(let ((s "%(^#{\")\"}^)"))
|
|
(ruby-assert-face s 3 font-lock-string-face)
|
|
(ruby-assert-face s 4 font-lock-variable-name-face)
|
|
(ruby-assert-face s 10 font-lock-string-face)
|
|
;; It's confused by the closing paren in the middle.
|
|
(ruby-assert-state s 8 nil)))
|
|
|
|
(ert-deftest ruby-interpolation-inside-another-interpolation ()
|
|
:expected-result :failed
|
|
(let ((s "\"#{[a, b, c].map { |v| \"#{v}\" }.join}\""))
|
|
(ruby-assert-face s 1 font-lock-string-face)
|
|
(ruby-assert-face s 2 font-lock-variable-name-face)
|
|
(ruby-assert-face s 38 font-lock-string-face)
|
|
(ruby-assert-state s 8 nil)))
|
|
|
|
(ert-deftest ruby-interpolation-inside-double-quoted-percent-literals ()
|
|
(ruby-assert-face "%Q{foo #@bar}" 8 font-lock-variable-name-face)
|
|
(ruby-assert-face "%W{foo #@bar}" 8 font-lock-variable-name-face)
|
|
(ruby-assert-face "%r{foo #@bar}" 8 font-lock-variable-name-face)
|
|
(ruby-assert-face "%x{foo #@bar}" 8 font-lock-variable-name-face))
|
|
|
|
(ert-deftest ruby-no-interpolation-in-single-quoted-literals ()
|
|
(ruby-assert-face "'foo #@bar'" 7 font-lock-string-face)
|
|
(ruby-assert-face "%q{foo #@bar}" 8 font-lock-string-face)
|
|
(ruby-assert-face "%w{foo #@bar}" 8 font-lock-string-face)
|
|
(ruby-assert-face "%s{foo #@bar}" 8 font-lock-string-face))
|
|
|
|
(ert-deftest ruby-interpolation-after-dollar-sign ()
|
|
(ruby-assert-face "\"$#{balance}\"" 2 'font-lock-string-face)
|
|
(ruby-assert-face "\"$#{balance}\"" 3 'font-lock-variable-name-face))
|
|
|
|
(ert-deftest ruby-no-unknown-percent-literals ()
|
|
;; No folding of case.
|
|
(ruby-assert-face "%S{foo}" 4 nil)
|
|
(ruby-assert-face "%R{foo}" 4 nil))
|
|
|
|
(ert-deftest ruby-no-nested-percent-literals ()
|
|
(ruby-with-temp-buffer "a = %w[b %()]"
|
|
(syntax-propertize (point))
|
|
(should (null (nth 8 (syntax-ppss))))
|
|
(should (eq t (nth 3 (syntax-ppss (1- (point-max))))))
|
|
(search-backward "[")
|
|
(should (eq t (nth 3 (syntax-ppss))))))
|
|
|
|
(ert-deftest ruby-add-log-current-method-examples ()
|
|
(let ((pairs '(("foo" . "#foo")
|
|
("C.foo" . ".foo")
|
|
("self.foo" . ".foo")
|
|
("<<" . "#<<"))))
|
|
(dolist (pair pairs)
|
|
(let ((name (car pair))
|
|
(value (cdr pair)))
|
|
(ruby-with-temp-buffer (ruby-test-string
|
|
"module M
|
|
| class C
|
|
| def %s
|
|
| _
|
|
| end
|
|
| end
|
|
|end"
|
|
name)
|
|
(search-backward "_")
|
|
(forward-line)
|
|
(should (string= (ruby-add-log-current-method)
|
|
(format "M::C%s" value))))))))
|
|
|
|
(ert-deftest ruby-add-log-current-method-outside-of-method ()
|
|
(ruby-with-temp-buffer (ruby-test-string
|
|
"module M
|
|
| class C
|
|
| def foo
|
|
| end
|
|
| _
|
|
| def bar
|
|
| end
|
|
| end
|
|
|end")
|
|
(search-backward "_")
|
|
(delete-char 1)
|
|
(should (string= (ruby-add-log-current-method)"M::C"))))
|
|
|
|
(ert-deftest ruby-add-log-current-method-in-singleton-class ()
|
|
(ruby-with-temp-buffer (ruby-test-string
|
|
"class C
|
|
| class << self
|
|
| def foo
|
|
| _
|
|
| end
|
|
| end
|
|
|end")
|
|
(search-backward "_")
|
|
(should (string= (ruby-add-log-current-method) "C.foo"))))
|
|
|
|
(ert-deftest ruby-add-log-current-method-namespace-shorthand ()
|
|
(ruby-with-temp-buffer (ruby-test-string
|
|
"class C::D
|
|
| def foo
|
|
| _
|
|
| end
|
|
|end")
|
|
(search-backward "_")
|
|
(should (string= (ruby-add-log-current-method) "C::D#foo"))))
|
|
|
|
(ert-deftest ruby-add-log-current-method-singleton-referencing-outer ()
|
|
(ruby-with-temp-buffer (ruby-test-string
|
|
"module M
|
|
| module N
|
|
| module C
|
|
| class D
|
|
| def C.foo
|
|
| _
|
|
| end
|
|
| end
|
|
| end
|
|
| end
|
|
|end")
|
|
(search-backward "_")
|
|
(should (string= (ruby-add-log-current-method) "M::N::C.foo"))))
|
|
|
|
(ert-deftest ruby-add-log-current-method-after-inner-class ()
|
|
(ruby-with-temp-buffer (ruby-test-string
|
|
"module M
|
|
| class C
|
|
| class D
|
|
| end
|
|
| def foo
|
|
| _
|
|
| end
|
|
| end
|
|
|end")
|
|
(search-backward "_")
|
|
(should (string= (ruby-add-log-current-method) "M::C#foo"))))
|
|
|
|
(ert-deftest ruby-add-log-current-method-after-inner-class-outside-methods ()
|
|
(ruby-with-temp-buffer (ruby-test-string
|
|
"module M
|
|
| class C
|
|
| class D
|
|
| end
|
|
|
|
|
|_
|
|
| end
|
|
|end")
|
|
(search-backward "_")
|
|
(delete-char 1)
|
|
(should (string= (ruby-add-log-current-method) "M::C"))))
|
|
|
|
(ert-deftest ruby-add-log-current-method-after-inner-class-outside-methods-with-text ()
|
|
(ruby-with-temp-buffer (ruby-test-string
|
|
"module M
|
|
| class C
|
|
| class D
|
|
| end
|
|
|
|
|
| FOO = 5
|
|
| end
|
|
|end")
|
|
(search-backward "FOO")
|
|
(should (string= (ruby-add-log-current-method) "M::C"))))
|
|
|
|
(ert-deftest ruby-add-log-current-method-after-endless-method ()
|
|
(ruby-with-temp-buffer (ruby-test-string
|
|
"module M
|
|
| class C
|
|
| def foo =
|
|
| 4_
|
|
| end
|
|
|end")
|
|
(search-backward "_")
|
|
(delete-char 1)
|
|
(should (string= (ruby-add-log-current-method) "M::C#foo"))))
|
|
|
|
(defvar ruby-block-test-example
|
|
(ruby-test-string
|
|
"class C
|
|
| def foo
|
|
| 1
|
|
| end
|
|
|
|
|
| def bar
|
|
| 2
|
|
| end
|
|
|
|
|
| def baz
|
|
|some do
|
|
|3
|
|
| end
|
|
| end
|
|
|end"))
|
|
|
|
(defmacro ruby-deftest-move-to-block (name &rest body)
|
|
(declare (indent defun))
|
|
`(ert-deftest ,(intern (format "ruby-move-to-block-%s" name)) ()
|
|
(with-temp-buffer
|
|
(insert ruby-block-test-example)
|
|
(ruby-mode)
|
|
(goto-char (point-min))
|
|
,@body)))
|
|
|
|
(ruby-deftest-move-to-block works-on-do
|
|
(forward-line 10)
|
|
(ruby-end-of-block)
|
|
(should (= 13 (line-number-at-pos)))
|
|
(ruby-beginning-of-block)
|
|
(should (= 11 (line-number-at-pos))))
|
|
|
|
(ruby-deftest-move-to-block zero-is-noop
|
|
(forward-line 4)
|
|
(ruby-move-to-block 0)
|
|
(should (= 5 (line-number-at-pos))))
|
|
|
|
(ruby-deftest-move-to-block ok-with-three
|
|
(forward-line 1)
|
|
(ruby-move-to-block 3)
|
|
(should (= 14 (line-number-at-pos))))
|
|
|
|
(ruby-deftest-move-to-block ok-with-minus-two
|
|
(forward-line 9)
|
|
(ruby-move-to-block -2)
|
|
(should (= 2 (line-number-at-pos))))
|
|
|
|
(ert-deftest ruby-move-to-block-skips-percent-literal ()
|
|
(dolist (s (list (ruby-test-string
|
|
"foo do
|
|
| a = %%w(
|
|
| def yaa
|
|
| )
|
|
|end")
|
|
(ruby-test-string
|
|
"foo do
|
|
| a = %%w|
|
|
| end
|
|
| |
|
|
|end")))
|
|
(ruby-with-temp-buffer s
|
|
(goto-char (point-min))
|
|
(ruby-end-of-block)
|
|
(should (= 5 (line-number-at-pos)))
|
|
(ruby-beginning-of-block)
|
|
(should (= 1 (line-number-at-pos))))))
|
|
|
|
(ert-deftest ruby-move-to-block-skips-heredoc ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"if something_wrong?
|
|
| ActiveSupport::Deprecation.warn(<<-eowarn)
|
|
| boo hoo
|
|
| end
|
|
| eowarn
|
|
|end")
|
|
(goto-char (point-min))
|
|
(ruby-end-of-block)
|
|
(should (= 6 (line-number-at-pos)))
|
|
(ruby-beginning-of-block)
|
|
(should (= 1 (line-number-at-pos)))))
|
|
|
|
(ert-deftest ruby-move-to-block-does-not-fold-case ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"foo do
|
|
| Module.to_s
|
|
|end")
|
|
(let ((case-fold-search t))
|
|
(ruby-beginning-of-block))
|
|
(should (= 1 (line-number-at-pos)))))
|
|
|
|
(ert-deftest ruby-move-to-block-moves-from-else-to-if ()
|
|
(ruby-with-temp-buffer (ruby-test-string
|
|
"if true
|
|
| nested_block do
|
|
| end
|
|
|else
|
|
|end")
|
|
(goto-char (point-min))
|
|
(forward-line 3)
|
|
(ruby-beginning-of-block)
|
|
(should (= 1 (line-number-at-pos)))))
|
|
|
|
(ert-deftest ruby-beginning-of-defun-does-not-fold-case ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"class C
|
|
| def bar
|
|
| Class.to_s
|
|
| end
|
|
|end")
|
|
(goto-char (point-min))
|
|
(forward-line 3)
|
|
(let ((case-fold-search t))
|
|
(beginning-of-defun))
|
|
(should (= 2 (line-number-at-pos)))))
|
|
|
|
(ert-deftest ruby-end-of-defun-skips-to-next-line-after-the-method ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"class D
|
|
| def tee
|
|
| 'ho hum'
|
|
| end
|
|
|end")
|
|
(goto-char (point-min))
|
|
(forward-line 1)
|
|
(end-of-defun)
|
|
(should (= 5 (line-number-at-pos)))))
|
|
|
|
(defvar ruby-sexp-test-example
|
|
(ruby-test-string
|
|
"class C
|
|
| def foo
|
|
| self.end
|
|
| D.new.class
|
|
| [1, 2, 3].map do |i|
|
|
| i + 1
|
|
| end.sum
|
|
| end
|
|
|end"))
|
|
|
|
(ert-deftest ruby-forward-sexp-skips-method-calls-with-keyword-names ()
|
|
(ruby-with-temp-buffer ruby-sexp-test-example
|
|
(goto-char (point-min))
|
|
(forward-line 1)
|
|
(forward-sexp)
|
|
(should (= 8 (line-number-at-pos)))))
|
|
|
|
(ert-deftest ruby-backward-sexp-skips-method-calls-with-keyword-names ()
|
|
(ruby-with-temp-buffer ruby-sexp-test-example
|
|
(goto-char (point-min))
|
|
(forward-line 7)
|
|
(end-of-line)
|
|
(backward-sexp)
|
|
(should (= 2 (line-number-at-pos)))))
|
|
|
|
(ert-deftest ruby-forward-sexp-jumps-do-end-block-with-no-args ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"proc do
|
|
|end")
|
|
(search-backward "do\n")
|
|
(forward-sexp)
|
|
(should (eobp))))
|
|
|
|
(ert-deftest ruby-backward-sexp-jumps-do-end-block-with-no-args ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"proc do
|
|
|end")
|
|
(goto-char (point-max))
|
|
(backward-sexp)
|
|
(should (looking-at "do$"))))
|
|
|
|
(ert-deftest ruby-forward-sexp-jumps-do-end-block-with-empty-args ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"proc do ||
|
|
|end")
|
|
(search-backward "do ")
|
|
(forward-sexp)
|
|
(should (eobp))))
|
|
|
|
(ert-deftest ruby-backward-sexp-jumps-do-end-block-with-empty-args ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"proc do ||
|
|
|end")
|
|
(goto-char (point-max))
|
|
(backward-sexp)
|
|
(should (looking-at "do "))))
|
|
|
|
(ert-deftest ruby-forward-sexp-jumps-do-end-block-with-args ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"proc do |a,b|
|
|
|end")
|
|
(search-backward "do ")
|
|
(forward-sexp)
|
|
(should (eobp))))
|
|
|
|
(ert-deftest ruby-backward-sexp-jumps-do-end-block-with-args ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"proc do |a,b|
|
|
|end")
|
|
(goto-char (point-max))
|
|
(backward-sexp)
|
|
(should (looking-at "do "))))
|
|
|
|
(ert-deftest ruby-forward-sexp-jumps-do-end-block-with-any-args ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"proc do |*|
|
|
|end")
|
|
(search-backward "do ")
|
|
(forward-sexp)
|
|
(should (eobp))))
|
|
|
|
(ert-deftest ruby-forward-sexp-jumps-do-end-block-with-expanded-one-arg ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"proc do |a,|
|
|
|end")
|
|
(search-backward "do ")
|
|
(forward-sexp)
|
|
(should (eobp))))
|
|
|
|
(ert-deftest ruby-forward-sexp-jumps-do-end-block-with-one-and-any-args ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"proc do |a,*|
|
|
|end")
|
|
(search-backward "do ")
|
|
(forward-sexp)
|
|
(should (eobp))))
|
|
|
|
(ert-deftest ruby-backward-sexp-jumps-do-end-block-with-one-and-any-args ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"proc do |a,*|
|
|
|end")
|
|
(goto-char (point-max))
|
|
(backward-sexp)
|
|
(should (looking-at "do "))))
|
|
|
|
(ert-deftest ruby-toggle-string-quotes-quotes-correctly ()
|
|
(let ((pairs
|
|
'(("puts '\"foo\"\\''" . "puts \"\\\"foo\\\"'\"")
|
|
("puts \"'foo'\\\"\"" . "puts '\\'foo\\'\"'"))))
|
|
(dolist (pair pairs)
|
|
(ruby-with-temp-buffer (car pair)
|
|
(beginning-of-line)
|
|
(search-forward "foo")
|
|
(ruby-toggle-string-quotes)
|
|
(should (string= (buffer-string) (cdr pair)))))))
|
|
|
|
(ert-deftest ruby--insert-coding-comment-ruby-style ()
|
|
(with-temp-buffer
|
|
(let ((ruby-encoding-magic-comment-style 'ruby))
|
|
(ruby--insert-coding-comment "utf-8")
|
|
(should (string= "# coding: utf-8\n" (buffer-string))))))
|
|
|
|
(ert-deftest ruby--insert-coding-comment-emacs-style ()
|
|
(with-temp-buffer
|
|
(let ((ruby-encoding-magic-comment-style 'emacs))
|
|
(ruby--insert-coding-comment "utf-8")
|
|
(should (string= "# -*- coding: utf-8 -*-\n" (buffer-string))))))
|
|
|
|
(ert-deftest ruby--insert-coding-comment-custom-style ()
|
|
(with-temp-buffer
|
|
(let ((ruby-encoding-magic-comment-style 'custom)
|
|
(ruby-custom-encoding-magic-comment-template "# encoding: %s\n"))
|
|
(ruby--insert-coding-comment "utf-8")
|
|
(should (string= "# encoding: utf-8\n\n" (buffer-string))))))
|
|
|
|
(ert-deftest ruby--set-encoding-when-ascii ()
|
|
(ruby-with-temp-file "ascii"
|
|
(let ((ruby-encoding-magic-comment-style 'ruby)
|
|
(ruby-insert-encoding-magic-comment t))
|
|
(setq save-buffer-coding-system 'us-ascii)
|
|
(ruby-mode-set-encoding)
|
|
(should (string= "ascii" (buffer-string))))))
|
|
|
|
(ert-deftest ruby--set-encoding-when-utf8 ()
|
|
(ruby-with-temp-file "💎"
|
|
(let ((ruby-encoding-magic-comment-style 'ruby)
|
|
(ruby-insert-encoding-magic-comment t))
|
|
(setq save-buffer-coding-system 'utf-8)
|
|
(ruby-mode-set-encoding)
|
|
(should (string= "💎" (buffer-string))))))
|
|
|
|
(ert-deftest ruby--set-encoding-when-latin-15 ()
|
|
(ruby-with-temp-file "Ⓡ"
|
|
(let ((ruby-encoding-magic-comment-style 'ruby)
|
|
(ruby-insert-encoding-magic-comment t))
|
|
(setq save-buffer-coding-system 'iso-8859-15)
|
|
(ruby-mode-set-encoding)
|
|
(should (string= "# coding: iso-8859-15\nⓇ" (buffer-string))))))
|
|
|
|
(ert-deftest ruby-imenu-with-private-modifier ()
|
|
(ruby-with-temp-buffer
|
|
(ruby-test-string
|
|
"class Blub
|
|
| def hi
|
|
| 'Hi!'
|
|
| end
|
|
|
|
|
| def bye
|
|
| 'Bye!'
|
|
| end
|
|
|
|
|
| private def hiding
|
|
| 'You can't see me'
|
|
| end
|
|
|end")
|
|
(should (equal (mapcar #'car (ruby-imenu-create-index))
|
|
'("Blub"
|
|
"Blub#hi"
|
|
"Blub#bye"
|
|
"Blub#hiding")))))
|
|
|
|
(defmacro ruby-deftest-indent (file)
|
|
`(ert-deftest ,(intern (format "ruby-indent-test/%s" file)) ()
|
|
;; :tags '(:expensive-test)
|
|
(let ((buf (find-file-noselect (ert-resource-file ,file))))
|
|
(unwind-protect
|
|
(with-current-buffer buf
|
|
(let ((orig (buffer-string)))
|
|
;; Indent and check that we get the original text.
|
|
(indent-region (point-min) (point-max))
|
|
(should (equal (buffer-string) orig))))
|
|
(kill-buffer buf)))))
|
|
|
|
(ruby-deftest-indent "ruby.rb")
|
|
(ruby-deftest-indent "ruby-after-operator-indent.rb")
|
|
(ruby-deftest-indent "ruby-block-indent.rb")
|
|
(ruby-deftest-indent "ruby-method-call-indent.rb")
|
|
(ruby-deftest-indent "ruby-method-params-indent.rb")
|
|
(ruby-deftest-indent "ruby-parenless-call-arguments-indent.rb")
|
|
(ruby-deftest-indent "ruby-bracketed-args-indent.rb")
|
|
|
|
(ert-deftest ruby--test-chained-indentation ()
|
|
(with-temp-buffer
|
|
(ruby-mode)
|
|
(setq-local ruby-align-chained-calls t)
|
|
(insert "some_variable.where
|
|
.not(x: nil)
|
|
.where(y: 2)
|
|
")
|
|
(indent-region (point-min) (point-max))
|
|
(should (equal (buffer-string)
|
|
"some_variable.where
|
|
.not(x: nil)
|
|
.where(y: 2)
|
|
")))
|
|
|
|
(with-temp-buffer
|
|
(ruby-mode)
|
|
(setq-local ruby-align-chained-calls t)
|
|
(insert "some_variable.where.not(x: nil)
|
|
.where(y: 2)
|
|
")
|
|
(indent-region (point-min) (point-max))
|
|
(should (equal (buffer-string)
|
|
"some_variable.where.not(x: nil)
|
|
.where(y: 2)
|
|
"))))
|
|
|
|
(provide 'ruby-mode-tests)
|
|
|
|
;;; ruby-mode-tests.el ends here
|