[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[elpa] master ce7a2be 20/62: Changed case-sensitivity to case-handling

From: Ian Dunn
Subject: [elpa] master ce7a2be 20/62: Changed case-sensitivity to case-handling
Date: Sat, 9 Dec 2017 14:33:59 -0500 (EST)

branch: master
commit ce7a2be39e23a061d83f69754f12d60c2f634ae4
Author: Ian Dunn <address@hidden>
Commit: Ian Dunn <address@hidden>

    Changed case-sensitivity to case-handling
    * paced.el (paced-dictionary): Added case-handling slot
      (paced-make-dictionary): Updated constructor.
      (paced--handle-word-case): New defun.
      (paced-dictionary-process-word): New dictionary method.
      (paced-add-word-to-dict): Use it.
    * paced-tests.el (paced-handle-word-case): Test case handling function.
      (paced-create-dictionary): Update constructor of dictionary.
 paced-tests.el | 10 +++++++++-
 paced.el       | 54 +++++++++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 52 insertions(+), 12 deletions(-)

diff --git a/paced-tests.el b/paced-tests.el
index 70ff440..2aa53d5 100644
--- a/paced-tests.el
+++ b/paced-tests.el
@@ -38,6 +38,14 @@
 (defconst paced-test-dict-save-file (paced-test-file 
+(ert-deftest paced-handle-word-case ()
+  (let* ((word "EiEiO"))
+    (should (string-equal (paced--handle-word-case 'preserve word) "EiEiO"))
+    (should (string-equal (paced--handle-word-case 'downcase word) "eieio"))
+    (should (string-equal (paced--handle-word-case 'upcase   word) "EIEIO"))
+    (should (string-equal (paced--handle-word-case 'downcase-first word) 
+    (should (string-equal (paced--handle-word-case 'upcase-first word) 
 (ert-deftest paced-create-dictionary ()
   (let* ((paced--registered-dictionaries nil)
          (target-file-exists (file-exists-p paced-test-dict-save-file))
@@ -45,7 +53,7 @@
                             (file-attribute-modification-time (file-attributes 
          (new-dict (paced-make-dictionary "test-dict-case"
-                                          t)))
+                                          'downcase)))
     (should (= (length paced--registered-dictionaries) 1))
     (should (paced-dictionary-p new-dict))
     (oset new-dict updated t) ;; Mark it as updated so it saves
diff --git a/paced.el b/paced.el
index f5c6c49..51f885e 100644
--- a/paced.el
+++ b/paced.el
@@ -163,14 +163,24 @@ entry should be of the form (VAR VALUE).")
                     "Header line for the save file.
 This is used with the `object-write' method.")
-   (case-sensitive :initarg :case-sensitive
-                   :initform nil
-                   :type boolean
-                   :custom boolean
-                   :label "Case Sensitive"
-                   :documentation "Non-nil if the dictionary should be case 
sensitive when populating.
-When nil, \"This\" will be the same as \"this\" in `usage-hash'.")
+   (case-handling :initarg :case-handling
+                  :initform downcase
+                  :type (member downcase upcase preserve downcase-first 
+                  :custom (choice (const :tag "Downcase All Words" downcase)
+                                  (const :tag "Upcase All Words" upcase)
+                                  (const :tag "Preserve Case" preserve)
+                                  (const :tag "Downcase Just the First Letter" 
+                                  (const :tag "Upcase Just the First Letter" 
+                  :label "Case Sensitive"
+                  :documentation "A symbol indicating how case should be 
handled during population.
+It can be one of the following:
+* downcase        Downcase every word
+* upcase          Upcase every word
+* preserve        Preserve case
+* downcase-first  Downcase the first letter of each word, leave the rest the 
+* upcase-first    Upcase the first letter of each word, leave the rest the 
    (updated :initarg :updated
             :initform nil
             :type boolean
@@ -216,7 +226,7 @@ instead.")
 (defsubst paced--ensure-dictionary-directory ()
   (make-directory paced-dictionary-directory t))
-(defun paced-make-dictionary (name filename case-sensitive)
+(defun paced-make-dictionary (name filename case-handling)
   "Make a paced dictionary called NAME.
 NAME is a symbol used to identify the new dictionary.
@@ -228,7 +238,7 @@ Return value is the new dictionary."
   (let ((new-dict (paced-dictionary
                    :object-name name
                    :file filename
-                   :case-sensitive case-sensitive)))
+                   :case-handling case-handling)))
     (paced-register-dictionary name new-dict)
@@ -430,12 +440,34 @@ Things is based on `paced-thing-at-point-constituent'."
   (interactive "p")
   (forward-thing paced-thing-at-point-constituent number))
+(defun paced--handle-word-case (case-handling word)
+  "Process WORD based on CASE-HANDLING.
+This is a separate function only for testing; use
+`paced-dictionary-process-word' instead."
+  (pcase case-handling
+    (`preserve word)
+    (`downcase (downcase word))
+    (`upcase (upcase word))
+    (`downcase-first
+     ;; Downcase the first letter
+     (concat (downcase (substring word 0 1))
+             (substring word 1)))
+    ;; Upcase the first letter
+    (`upcase-first
+     (concat (upcase (substring word 0 1))
+             (substring word 1)))))
+(cl-defmethod paced-dictionary-process-word ((dict paced-dictionary) word)
+  "Return WORD, modified based on DICT's case handling."
+  (paced--handle-word-case (oref dict case-handling) word))
 (defsubst paced-add-word-to-dict (dict word)
   "Add WORD to paced dictionary DICT."
   ;; If I've got a word uppercase and lowercase in my usage table, I'm
   ;; going to have repeats when ignore case is enabled.  To solve this,
   ;; downcase everything when not case sensitive.
-  (let ((new-word (if (oref dict case-sensitive) word (downcase word))))
+  (let ((new-word (paced-dictionary-process-word dict word)))
     ;; Use the full name here to silence the byte-compiler
     (cl-incf (map-elt (oref dict usage-hash) new-word 0))
     (oset dict updated t)))

reply via email to

[Prev in Thread] Current Thread [Next in Thread]