From 5758bef84cdaa4676a7262d347b2f655c5b2f986 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Arthur=20Fayzrakhmanov=20=28=D0=90=D1=80=D1=82=D1=83=D1=80?= =?UTF-8?q?=20=D0=A4=D0=B0=D0=B9=D0=B7=D1=80=D0=B0=D1=85=D0=BC=D0=B0=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=29?= Date: Wed, 17 Jun 2015 18:10:00 +0500 Subject: [PATCH 1/7] Define pragma prefix grabbing function Define a function which grabs completion prefixes for pragma names (WARNING, LANGUAGE, etc.), and handles special cases of OPTIONS_GHC pragma and LANGUAGE pragma returning prefixes for options or language extensions respectively. --- haskell-completions.el | 71 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) diff --git a/haskell-completions.el b/haskell-completions.el index 5709a9867..c8d0e1233 100644 --- a/haskell-completions.el +++ b/haskell-completions.el @@ -42,5 +42,76 @@ whitespace or new line, otherwise returns nil. (backward-char) (not (looking-at (rx (| space line-end))))))))) +(defun haskell-completions-grab-pragma-prefix () + "Grab completion prefix for pragma completions. +Returns a list of form '(prefix-start-position +prefix-end-position prefix-value prefix-type) for pramga names +such as WARNING, DEPRECATED, LANGUAGE and etc. Also returns +completion prefixes for options in case OPTIONS_GHC pragma, or +language extensions in case of LANGUAGE pragma. Obsolete OPTIONS +pragma is supported also." + (when (nth 4 (syntax-ppss)) + ;; We're inside comment + (let ((p (point)) + (comment-start (nth 8 (syntax-ppss))) + (case-fold-search nil) + prefix-start + prefix-end + prefix-type + prefix-value) + (save-excursion + (goto-char comment-start) + (when (looking-at (rx "{-#" (1+ (| space "\n")))) + (let ((pragma-start (match-end 0))) + (when (> p pragma-start) + ;; point stands after `{-#` + (goto-char pragma-start) + (when (looking-at (rx (1+ (| upper "_")))) + ;; found suitable sequence for pragma name + (let ((pragma-end (match-end 0)) + (pragma-value (match-string-no-properties 0))) + (if (eq p pragma-end) + ;; point is at the end of (in)complete pragma name + ;; prepare resulting values + (progn + (setq prefix-start pragma-start) + (setq prefix-end pragma-end) + (setq prefix-value pragma-value) + (setq prefix-type + 'haskell-completions-pragma-name-prefix)) + (when (and (> p pragma-end) + (or (equal "OPTIONS_GHC" pragma-value) + (equal "OPTIONS" pragma-value) + (equal "LANGUAGE" pragma-value))) + ;; point is after pragma name, so we need to check + ;; special cases of `OPTIONS_GHC` and `LANGUAGE` pragmas + ;; and provide a completion prefix for possible ghc + ;; option or language extension. + (goto-char pragma-end) + (when (re-search-forward + (rx (* anything) + (1+ (regexp "\\S-"))) + p + t) + (let* ((str (match-string-no-properties 0)) + (split (split-string str (rx (| space "\n")) t)) + (val (car (last split))) + (end (point))) + (when (and (equal p end) + (not (string-match-p "#" val))) + (setq prefix-value val) + (backward-char (length val)) + (setq prefix-start (point)) + (setq prefix-end end) + (setq + prefix-type + (if (not (equal "LANGUAGE" pragma-value)) + 'haskell-completions-ghc-option-prefix + 'haskell-completions-language-extension-prefix + ))))))))))))) + (when prefix-value + (list prefix-start prefix-end prefix-value prefix-type))))) + + (provide 'haskell-completions) ;;; haskell-completions.el ends here From c2fb042c0f106b13a79e3c330cb6d5048f24c95a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Arthur=20Fayzrakhmanov=20=28=D0=90=D1=80=D1=82=D1=83=D1=80?= =?UTF-8?q?=20=D0=A4=D0=B0=D0=B9=D0=B7=D1=80=D0=B0=D1=85=D0=BC=D0=B0=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=29?= Date: Wed, 17 Jun 2015 18:17:19 +0500 Subject: [PATCH 2/7] Define tests for `haskell-completions-grab-pragma-prefix` --- tests/haskell-completions-tests.el | 168 +++++++++++++++++++++++++++++ 1 file changed, 168 insertions(+) diff --git a/tests/haskell-completions-tests.el b/tests/haskell-completions-tests.el index b8c40b364..948188df5 100644 --- a/tests/haskell-completions-tests.el +++ b/tests/haskell-completions-tests.el @@ -70,5 +70,173 @@ (should (eql nil (haskell-completions-can-grab-prefix)))))) +(ert-deftest haskell-completions-grab-pragma-prefix-nil-cases-test () + "Tests the function `haskell-completions-grab-pragma-prefix' +within empty pragma comment {-# #-} and outside of it." + (with-temp-buffer + (haskell-mode) + (goto-char (point-min)) + (insert "{") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert "-") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert "#") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert " ") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert "#") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert "-") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert "}") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert "\n") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert "main") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert ":: IO ()") + (should (eql nil (haskell-completions-grab-pragma-prefix))))) + +(ert-deftest haskell-completions-grab-pragma-name-prefix-test () + "Tests the function `haskell-completions-grab-pragma-prefix' +for pragma names completions such as WARNING, LANGUAGE, +DEPRECATED and etc." + (let ((expected (list 5 8 "LAN" 'haskell-completions-pragma-name-prefix))) + (with-temp-buffer + (haskell-mode) + (goto-char (point-min)) + (insert "{-# LAN") + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (save-excursion (insert " #-}")) + ;; should work in case of closed comment, e.g. {-# LAN| #-} + (should (equal expected (haskell-completions-grab-pragma-prefix))) + ;; pragma function should work in the middle of word + (backward-char) + (should (not (equal expected (haskell-completions-grab-pragma-prefix))))) + (with-temp-buffer + (haskell-mode) + (goto-char (point-min)) + (insert "{-#\nLAN") + ;; should work for multiline case + (should (equal expected (haskell-completions-grab-pragma-prefix)))))) + +(ert-deftest haskell-completions-grab-ghc-options-prefix-test-01 () + "Tests the function `haskell-completions-grab-pragma-prefix' +for GHC options prefixes." + (let (expected) + (with-temp-buffer + (haskell-mode) + (goto-char (point-min)) + (setq expected + (list 5 16 "OPTIONS_GHC" 'haskell-completions-pragma-name-prefix)) + (insert "{-# OPTIONS_GHC") + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (insert " --opt1") + (setq expected + (list 17 23 "--opt1" 'haskell-completions-ghc-option-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (insert " -XOpt-2") + (setq expected + (list 27 34 "-XOpt-2" 'haskell-completions-ghc-option-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (save-excursion + (insert "\n") + (insert "\"new-line\"") + ;; should handle multiline case + (setq + expected + (list 35 45 "\"new-line\"" 'haskell-completions-ghc-option-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (insert " test ") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert "#-}")) + ;; should work in case of closed comment, e.g. {-# OPTIONS_GHC xyz| #-} + (setq expected + (list 27 34 "-XOpt-2" 'haskell-completions-ghc-option-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (backward-char) + ;; pragma function should work in the middle of word + (should (not (eql nil (haskell-completions-grab-pragma-prefix))))))) + +(ert-deftest haskell-completions-grab-ghc-options-prefix-test-02 () + "Tests the function `haskell-completions-grab-pragma-prefix' +for GHC options prefixes. Same tests as above for obsolete +OPTIONS pragma." + (let (expected) + (with-temp-buffer + (haskell-mode) + (goto-char (point-min)) + (insert "{-# OPTIONS") + (setq expected + (list 5 12 "OPTIONS" 'haskell-completions-pragma-name-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (insert " --opt1") + (setq expected + (list 13 19 "--opt1" 'haskell-completions-ghc-option-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (insert " -XOpt-2") + (setq expected + (list 23 30 "-XOpt-2" 'haskell-completions-ghc-option-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (save-excursion + (insert "\n") + (insert "\"new-line\"") + ;; should handle multiline case + (setq + expected + (list 31 41 "\"new-line\"" 'haskell-completions-ghc-option-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (insert " test ") + (should (eql nil (haskell-completions-grab-pragma-prefix))) + (insert "#-}")) + ;; should work in case of closed comment + (setq expected + (list 23 30 "-XOpt-2" 'haskell-completions-ghc-option-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (backward-char) + ;; pragma function should work in the middle of word + (should (not (eql nil (haskell-completions-grab-pragma-prefix))))))) + +(ert-deftest haskell-completions-grab-language-extenstion-prefix-test () + "Tests both function `haskell-completions-grab-pragma-prefix' +and function `haskell-completions-grab-prefix' for language +extension prefixes." + (let (expected) + (with-temp-buffer + (haskell-mode) + (goto-char (point-min)) + (insert "{-# LANGUAGE") + (setq expected + (list 5 13 "LANGUAGE" 'haskell-completions-pragma-name-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (insert " Rec") + (setq expected + (list 14 17 "Rec" 'haskell-completions-language-extension-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (insert ", -XOpt-2") + (setq + expected + (list 22 29 "-XOpt-2" 'haskell-completions-language-extension-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (insert ",\n") + (insert "\"new-line\"") + ;; should handle multiline case + (setq expected + (list 31 + 41 + "\"new-line\"" + 'haskell-completions-language-extension-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (insert " -test") + (save-excursion (insert " #-}")) + ;; should work in case of closed comment + (setq expected + (list 42 47 "-test" 'haskell-completions-language-extension-prefix)) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (backward-char) + ;; pragma function should work in the middle of the word + (should (not (eql nil (haskell-completions-grab-pragma-prefix))))))) + + (provide 'haskell-completions-tests) ;;; haskell-completions-tests.el ends here From 73c1b8d19c833febd89e9a15fd7fc7044fc3f35c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Arthur=20Fayzrakhmanov=20=28=D0=90=D1=80=D1=82=D1=83=D1=80?= =?UTF-8?q?=20=D0=A4=D0=B0=D0=B9=D0=B7=D1=80=D0=B0=D1=85=D0=BC=D0=B0=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=29?= Date: Wed, 17 Jun 2015 18:19:37 +0500 Subject: [PATCH 3/7] Define an ident prefix grabbing function --- haskell-completions.el | 54 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/haskell-completions.el b/haskell-completions.el index c8d0e1233..abd5d026f 100644 --- a/haskell-completions.el +++ b/haskell-completions.el @@ -28,6 +28,9 @@ ;;; Code: +(require 'haskell-mode) + + (defun haskell-completions-can-grab-prefix () "Check if the case is appropriate for grabbing completion prefix. Returns t if point is either at whitespace character, or at @@ -112,6 +115,57 @@ pragma is supported also." (when prefix-value (list prefix-start prefix-end prefix-value prefix-type))))) +(defun haskell-completions-grab-identifier-prefix () + "Grab completion prefix for identifier at point. +Returns a list of form '(prefix-start-position +prefix-end-position prefix-value prefix-type) for haskell +identifier at point depending on result of function +`haskell-ident-pos-at-point'." + (let ((pos-at-point (haskell-ident-pos-at-point)) + (p (point))) + (when pos-at-point + (let* ((start (car pos-at-point)) + (end (cdr pos-at-point)) + (type 'haskell-completions-identifier-prefix) + (case-fold-search nil) + value) + ;; we need end position of result, becase of + ;; `haskell-ident-pos-at-point' ignores trailing whitespace, e.g. the + ;; result will be same for `map|` and `map |` invocations. + (when (<= p end) + (setq end p) + (setq value (buffer-substring-no-properties start end)) + (when (string-match-p (rx bos upper) value) + ;; we need to check if found identifier is a module name + (save-excursion + (goto-char (line-beginning-position)) + (when (re-search-forward + (rx "import" + (? (1+ space) "qualified") + (1+ space) + upper + (1+ (| alnum "."))) + p ;; bound + t) ;; no-error + (if (equal p (point)) + (setq type 'haskell-completions-module-name-prefix) + (when (re-search-forward + (rx (| " as " "(")) + start + t) + ;; but uppercase ident could occur after `as` keyword, or in + ;; module imports after opening parenthesis, in this case + ;; restore identifier type again, it's neccessary to + ;; distinguish the means of completions retrieval + (setq type 'haskell-completions-identifier-prefix)))))) + (when (nth 8 (syntax-ppss)) + ;; eighth element of syntax-ppss result is string or comment start, + ;; so when it's not nil word at point is inside string or comment, + ;; return special literal prefix type + (setq type 'haskell-completions-general-prefix)) + ;; finally take in account minlen if given and return the result + (when value (list start end value type))))))) + (provide 'haskell-completions) ;;; haskell-completions.el ends here From 0aeae56ad30d7b8b22600c33d0539aa8ba291710 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Arthur=20Fayzrakhmanov=20=28=D0=90=D1=80=D1=82=D1=83=D1=80?= =?UTF-8?q?=20=D0=A4=D0=B0=D0=B9=D0=B7=D1=80=D0=B0=D1=85=D0=BC=D0=B0=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=29?= Date: Wed, 17 Jun 2015 18:23:31 +0500 Subject: [PATCH 4/7] Define tests for `haskell-completions-grab-identifier-prefix` --- tests/haskell-completions-tests.el | 81 ++++++++++++++++++++++++++++++ 1 file changed, 81 insertions(+) diff --git a/tests/haskell-completions-tests.el b/tests/haskell-completions-tests.el index 948188df5..e813c46ee 100644 --- a/tests/haskell-completions-tests.el +++ b/tests/haskell-completions-tests.el @@ -236,6 +236,87 @@ extension prefixes." (backward-char) ;; pragma function should work in the middle of the word (should (not (eql nil (haskell-completions-grab-pragma-prefix))))))) +(ert-deftest haskell-completions-grab-identifier-prefix-test () + "Tests the function +`haskell-completions-grab-identifier-prefix' for arbitrary +haskell identifiers and module identifiers." + (let (expected) + (with-temp-buffer + (haskell-mode) + (should (eql nil (haskell-completions-grab-identifier-prefix))) + (insert "import") + (setq expected (list 1 7 "import" 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert " Da") + (setq expected (list 8 10 "Da" 'haskell-completions-module-name-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert "ta.") + (setq expected + (list 8 13 "Data." 'haskell-completions-module-name-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert "Text (pack") + (setq expected (list 19 23 "pack" 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert ")") + ;; should work when point is at punctuation + (backward-char) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (forward-char) + ;; but should not work after punctuation + (should (eql nil (haskell-completions-grab-identifier-prefix))) + (insert "\n") + (insert "import qualified Data.Text as T") + (insert "\n\n") + ;; should not work at the beginning of a line + (should (eql nil (haskell-completions-grab-identifier-prefix))) + (insert "main") + (setq expected (list 58 62 "main" 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert " :: IO") + (setq expected (list 66 68 "IO" 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert " ()\n") + (insert "main") + (save-excursion + (insert " = putStrLn") + (setq expected + (list 79 87 "putStrLn" 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert " (T.") + (setq expected (list 89 91 "T." 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert "unpack") + (setq expected + (list 89 97 "T.unpack" 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert " (T.pack (\"Hello") + (setq expected + (list 108 113 "Hello" 'haskell-completions-general-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert " World!\" :: String") + (setq expected + (list 125 131 "String" 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert " -- Comment") + (setq expected + (list 135 142 "Comment" 'haskell-completions-general-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix)))) + ;; test in the middle of line + (setq expected (list 72 76 "main" 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (backward-char) + (setq expected (list 72 75 "mai" 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix)))) + ;; qualified imports and "as indentifier" tests + (with-temp-buffer + (haskell-mode) + (insert "import qualified Data.Text") + (setq expected + (list 18 27 "Data.Text" 'haskell-completions-module-name-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (insert " as T") + (setq expected (list 31 32 "T" 'haskell-completions-identifier-prefix)) + (should (equal expected (haskell-completions-grab-identifier-prefix)))))) (provide 'haskell-completions-tests) From a5ac0b4dc20d8cc37d1f949a04122618abbca64c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Arthur=20Fayzrakhmanov=20=28=D0=90=D1=80=D1=82=D1=83=D1=80?= =?UTF-8?q?=20=D0=A4=D0=B0=D0=B9=D0=B7=D1=80=D0=B0=D1=85=D0=BC=D0=B0=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=29?= Date: Wed, 17 Jun 2015 18:27:50 +0500 Subject: [PATCH 5/7] Define general completion prefix grabbing function --- haskell-completions.el | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/haskell-completions.el b/haskell-completions.el index abd5d026f..ae44bca6f 100644 --- a/haskell-completions.el +++ b/haskell-completions.el @@ -26,6 +26,14 @@ ;; This package provides completions related functionality for ;; Haskell Mode such grab completion prefix at point, and etc.. +;; Some description +;; ================ +;; +;; For major use function `haskell-completions-grab-prefix' is supposed, and +;; other prefix grabbing functions are used internally by it. So, only this +;; funciton have prefix minimal length functionality and invokes predicate +;; function `haskell-completions-can-grab-prefix'. + ;;; Code: (require 'haskell-mode) @@ -166,6 +174,25 @@ identifier at point depending on result of function ;; finally take in account minlen if given and return the result (when value (list start end value type))))))) +(defun haskell-completions-grab-prefix (&optional minlen) + "Grab prefix at point for possible completion. +Returns a list of form '(prefix-start-position +prefix-end-position prefix-value prefix-type) depending on +situation, e.g. is it needed to complete pragma, module name, +arbitrary identifier, and etc. Rerurns nil in case it is +impossible to grab prefix. + +If provided optional MINLEN parameter this function will return +result only if prefix length is not less than MINLEN." + (when (haskell-completions-can-grab-prefix) + (let ((prefix (cond + ((haskell-completions-grab-pragma-prefix)) + ((haskell-completions-grab-identifier-prefix))))) + (cond ((and minlen prefix) + (when (>= (length (nth 2 prefix)) minlen) + prefix)) + (prefix prefix))))) + (provide 'haskell-completions) ;;; haskell-completions.el ends here From 10a49525145758da496d16b25bb6f4db345a6eb1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Arthur=20Fayzrakhmanov=20=28=D0=90=D1=80=D1=82=D1=83=D1=80?= =?UTF-8?q?=20=D0=A4=D0=B0=D0=B9=D0=B7=D1=80=D0=B0=D1=85=D0=BC=D0=B0=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=29?= Date: Wed, 17 Jun 2015 18:29:58 +0500 Subject: [PATCH 6/7] Add tests for `haskell-completions-grab-prefix` function --- tests/haskell-completions-tests.el | 119 +++++++++++++++++++++++------ 1 file changed, 96 insertions(+), 23 deletions(-) diff --git a/tests/haskell-completions-tests.el b/tests/haskell-completions-tests.el index e813c46ee..2bb993270 100644 --- a/tests/haskell-completions-tests.el +++ b/tests/haskell-completions-tests.el @@ -98,31 +98,39 @@ within empty pragma comment {-# #-} and outside of it." (should (eql nil (haskell-completions-grab-pragma-prefix))))) (ert-deftest haskell-completions-grab-pragma-name-prefix-test () - "Tests the function `haskell-completions-grab-pragma-prefix' -for pragma names completions such as WARNING, LANGUAGE, -DEPRECATED and etc." + "Tests both `haskell-completions-grab-pragma-prefix' and +`haskell-completions-grab-prefix' functions for pragma names +completions such as WARNING, LANGUAGE, DEPRECATED and etc." (let ((expected (list 5 8 "LAN" 'haskell-completions-pragma-name-prefix))) (with-temp-buffer (haskell-mode) (goto-char (point-min)) (insert "{-# LAN") (should (equal expected (haskell-completions-grab-pragma-prefix))) + ;; minimal prefix length + (should (equal expected (haskell-completions-grab-prefix 3))) + (should (eql nil (haskell-completions-grab-prefix 4))) (save-excursion (insert " #-}")) ;; should work in case of closed comment, e.g. {-# LAN| #-} (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) ;; pragma function should work in the middle of word (backward-char) - (should (not (equal expected (haskell-completions-grab-pragma-prefix))))) + (should (not (equal expected (haskell-completions-grab-pragma-prefix)))) + ;; but general function should not + (should (eql nil (haskell-completions-grab-prefix)))) (with-temp-buffer (haskell-mode) (goto-char (point-min)) (insert "{-#\nLAN") ;; should work for multiline case - (should (equal expected (haskell-completions-grab-pragma-prefix)))))) + (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix)))))) (ert-deftest haskell-completions-grab-ghc-options-prefix-test-01 () - "Tests the function `haskell-completions-grab-pragma-prefix' -for GHC options prefixes." + "Tests both `haskell-completions-grab-pragma-prefix' and +`haskell-completions-grab-prefix' functions for GHC options +prefixes." (let (expected) (with-temp-buffer (haskell-mode) @@ -131,14 +139,17 @@ for GHC options prefixes." (list 5 16 "OPTIONS_GHC" 'haskell-completions-pragma-name-prefix)) (insert "{-# OPTIONS_GHC") (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " --opt1") (setq expected (list 17 23 "--opt1" 'haskell-completions-ghc-option-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " -XOpt-2") (setq expected (list 27 34 "-XOpt-2" 'haskell-completions-ghc-option-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (save-excursion (insert "\n") (insert "\"new-line\"") @@ -147,21 +158,32 @@ for GHC options prefixes." expected (list 35 45 "\"new-line\"" 'haskell-completions-ghc-option-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) - (insert " test ") + (should (equal expected (haskell-completions-grab-prefix))) + (insert " test") + (setq expected + (list 46 50 "test" 'haskell-completions-ghc-option-prefix)) + ;; minimal prefix length + (should (equal expected (haskell-completions-grab-prefix 4))) + (should (eql nil (haskell-completions-grab-prefix 5))) + (insert " ") (should (eql nil (haskell-completions-grab-pragma-prefix))) + (should (eql nil (haskell-completions-grab-prefix))) (insert "#-}")) ;; should work in case of closed comment, e.g. {-# OPTIONS_GHC xyz| #-} (setq expected (list 27 34 "-XOpt-2" 'haskell-completions-ghc-option-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (backward-char) ;; pragma function should work in the middle of word - (should (not (eql nil (haskell-completions-grab-pragma-prefix))))))) + (should (not (eql nil (haskell-completions-grab-pragma-prefix)))) + ;; but general function should not + (should (eql nil (haskell-completions-grab-prefix)))))) (ert-deftest haskell-completions-grab-ghc-options-prefix-test-02 () - "Tests the function `haskell-completions-grab-pragma-prefix' -for GHC options prefixes. Same tests as above for obsolete -OPTIONS pragma." + "Tests both `haskell-completions-grab-pragma-prefix' and +`haskell-completions-grab-prefix' functions for GHC options prefixes. Same +tests as above for obsolete OPTIONS pragma." (let (expected) (with-temp-buffer (haskell-mode) @@ -170,14 +192,17 @@ OPTIONS pragma." (setq expected (list 5 12 "OPTIONS" 'haskell-completions-pragma-name-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " --opt1") (setq expected (list 13 19 "--opt1" 'haskell-completions-ghc-option-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " -XOpt-2") (setq expected (list 23 30 "-XOpt-2" 'haskell-completions-ghc-option-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (save-excursion (insert "\n") (insert "\"new-line\"") @@ -186,20 +211,31 @@ OPTIONS pragma." expected (list 31 41 "\"new-line\"" 'haskell-completions-ghc-option-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) - (insert " test ") + (should (equal expected (haskell-completions-grab-prefix))) + (insert " test") + ;; minimal prefix length + (setq expected + (list 42 46 "test" 'haskell-completions-ghc-option-prefix)) + (should (equal expected (haskell-completions-grab-prefix 4))) + (should (eql nil (haskell-completions-grab-prefix 5))) + (insert " ") (should (eql nil (haskell-completions-grab-pragma-prefix))) + (should (eql nil (haskell-completions-grab-prefix))) (insert "#-}")) ;; should work in case of closed comment (setq expected (list 23 30 "-XOpt-2" 'haskell-completions-ghc-option-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (backward-char) ;; pragma function should work in the middle of word - (should (not (eql nil (haskell-completions-grab-pragma-prefix))))))) + (should (not (eql nil (haskell-completions-grab-pragma-prefix)))) + ;; but general function should not + (should (eql nil (haskell-completions-grab-prefix)))))) (ert-deftest haskell-completions-grab-language-extenstion-prefix-test () - "Tests both function `haskell-completions-grab-pragma-prefix' -and function `haskell-completions-grab-prefix' for language + "Tests both `haskell-completions-grab-pragma-prefix' and +`haskell-completions-grab-prefix' functions for language extension prefixes." (let (expected) (with-temp-buffer @@ -209,15 +245,18 @@ extension prefixes." (setq expected (list 5 13 "LANGUAGE" 'haskell-completions-pragma-name-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " Rec") (setq expected (list 14 17 "Rec" 'haskell-completions-language-extension-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert ", -XOpt-2") (setq expected (list 22 29 "-XOpt-2" 'haskell-completions-language-extension-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert ",\n") (insert "\"new-line\"") ;; should handle multiline case @@ -227,54 +266,78 @@ extension prefixes." "\"new-line\"" 'haskell-completions-language-extension-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " -test") + ;; minimal prefix length + (setq expected + (list 42 47 "-test" 'haskell-completions-language-extension-prefix)) + (should (equal expected (haskell-completions-grab-prefix 5))) + (should (eql nil (haskell-completions-grab-prefix 6))) (save-excursion (insert " #-}")) ;; should work in case of closed comment (setq expected (list 42 47 "-test" 'haskell-completions-language-extension-prefix)) (should (equal expected (haskell-completions-grab-pragma-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (backward-char) ;; pragma function should work in the middle of the word - (should (not (eql nil (haskell-completions-grab-pragma-prefix))))))) + (should (not (eql nil (haskell-completions-grab-pragma-prefix)))) + ;; but general function does not + (should (eql nil (haskell-completions-grab-prefix)))))) + + (ert-deftest haskell-completions-grab-identifier-prefix-test () - "Tests the function -`haskell-completions-grab-identifier-prefix' for arbitrary -haskell identifiers and module identifiers." + "Tests both `haskell-completions-grab-identifier-prefix' and +`haskell-completions-grab-prefix' functions for arbitrary haskell +identifiers and module identifiers." (let (expected) (with-temp-buffer (haskell-mode) (should (eql nil (haskell-completions-grab-identifier-prefix))) + (should (eql nil (haskell-completions-grab-prefix))) (insert "import") (setq expected (list 1 7 "import" 'haskell-completions-identifier-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " Da") (setq expected (list 8 10 "Da" 'haskell-completions-module-name-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) + ;; minimal length test + (should (equal expected (haskell-completions-grab-prefix 2))) + (should (eql nil (haskell-completions-grab-prefix 3))) (insert "ta.") (setq expected (list 8 13 "Data." 'haskell-completions-module-name-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert "Text (pack") (setq expected (list 19 23 "pack" 'haskell-completions-identifier-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert ")") ;; should work when point is at punctuation (backward-char) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (forward-char) ;; but should not work after punctuation (should (eql nil (haskell-completions-grab-identifier-prefix))) + (should (eql nil (haskell-completions-grab-prefix))) (insert "\n") (insert "import qualified Data.Text as T") (insert "\n\n") ;; should not work at the beginning of a line (should (eql nil (haskell-completions-grab-identifier-prefix))) + (should (eql nil (haskell-completions-grab-prefix))) (insert "main") (setq expected (list 58 62 "main" 'haskell-completions-identifier-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " :: IO") (setq expected (list 66 68 "IO" 'haskell-completions-identifier-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " ()\n") (insert "main") (save-excursion @@ -282,31 +345,39 @@ haskell identifiers and module identifiers." (setq expected (list 79 87 "putStrLn" 'haskell-completions-identifier-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " (T.") (setq expected (list 89 91 "T." 'haskell-completions-identifier-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert "unpack") (setq expected (list 89 97 "T.unpack" 'haskell-completions-identifier-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " (T.pack (\"Hello") (setq expected (list 108 113 "Hello" 'haskell-completions-general-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " World!\" :: String") (setq expected (list 125 131 "String" 'haskell-completions-identifier-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " -- Comment") (setq expected (list 135 142 "Comment" 'haskell-completions-general-prefix)) - (should (equal expected (haskell-completions-grab-identifier-prefix)))) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix)))) ;; test in the middle of line (setq expected (list 72 76 "main" 'haskell-completions-identifier-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (backward-char) (setq expected (list 72 75 "mai" 'haskell-completions-identifier-prefix)) - (should (equal expected (haskell-completions-grab-identifier-prefix)))) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal nil (haskell-completions-grab-prefix)))) ;; qualified imports and "as indentifier" tests (with-temp-buffer (haskell-mode) @@ -314,9 +385,11 @@ haskell identifiers and module identifiers." (setq expected (list 18 27 "Data.Text" 'haskell-completions-module-name-prefix)) (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix))) (insert " as T") (setq expected (list 31 32 "T" 'haskell-completions-identifier-prefix)) - (should (equal expected (haskell-completions-grab-identifier-prefix)))))) + (should (equal expected (haskell-completions-grab-identifier-prefix))) + (should (equal expected (haskell-completions-grab-prefix)))))) (provide 'haskell-completions-tests) From 92bd153f5e420c0bcfe56f5cddc314beb25af949 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Arthur=20Fayzrakhmanov=20=28=D0=90=D1=80=D1=82=D1=83=D1=80?= =?UTF-8?q?=20=D0=A4=D0=B0=D0=B9=D0=B7=D1=80=D0=B0=D1=85=D0=BC=D0=B0=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=29?= Date: Wed, 17 Jun 2015 18:31:09 +0500 Subject: [PATCH 7/7] Update outdated commentaries --- haskell.el | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/haskell.el b/haskell.el index 88f520f3a..1fb1208a6 100644 --- a/haskell.el +++ b/haskell.el @@ -74,7 +74,8 @@ (end (match-end 1))) (list start end (haskell-process-get-repl-completions process text)))) - ;; Complete OPTIONS using :complete repl ":set ..." + ;; Complete OPTIONS, a completion list comes from variable + ;; `haskell-ghc-supported-options' ((and (nth 4 (syntax-ppss)) (save-excursion (let ((p (point))) @@ -84,7 +85,8 @@ (rx symbol-start "-" (* (char alnum ?-))) (line-beginning-position))) (list (match-beginning 0) (match-end 0) haskell-ghc-supported-options)) - ;; Complete LANGUAGE :complete repl ":set -X..." + ;; Complete LANGUAGE, a list of completions comes from variable + ;; `haskell-ghc-supported-options' ((and (nth 4 (syntax-ppss)) (save-excursion (let ((p (point)))