[elpa] externals/ebdb e80753a 264/350: Change ebdb-record-change-name to accept strings

[Eric Abrahamsen]

branch: externals/ebdb
commit e80753a709d50d4e3f736f3de476b363cdf527ef
Author: Eric Abrahamsen <address@hidden>
Commit: Eric Abrahamsen <address@hidden>

    Change ebdb-record-change-name to accept strings
    
    The fact that person and organization record types take different name
    classes is still causing a little difficulty. We address this by
    allowing ebdb-record-change-name to accept a string argument, meaning
    that the parsing can happen within the record-class-specific method.
    That should remove most of the leaky abstractions from various points
    in the code.
    
    * ebdb.el (ebdb-record-change-name): Provide a generic, for eldoc
      purposes. Provide person- and organization-specific methods that can
      accept strings. Take care of business inside those methods. Also,
      only set the 'name-string cache slot within the base method.
    * ebdb-com.el (ebdb-edit-field): Adjust for new system -- it's
      necessary to read the new name here: do it with the right class, and
      the old instance as default.
    * ebdb-mua.el (ebdb-annotate-message): Destroy "name-slot" with
      maximum prejudice.
---
 ebdb-com.el |  4 +++-
 ebdb-mua.el | 33 ++++++++-------------------------
 ebdb.el     | 33 +++++++++++++++++++--------------
 3 files changed, 30 insertions(+), 40 deletions(-)

diff --git a/ebdb-com.el b/ebdb-com.el
index 6123726..e01ab49 100644
--- a/ebdb-com.el
+++ b/ebdb-com.el
@@ -1637,7 +1637,9 @@ the record, change the name of the record."
   (let ((header-p (get-text-property (point) 'ebdb-record)))
     (ebdb-with-record-edits (r (list record))
       (if header-p
-         (ebdb-record-change-name r)
+         (let* ((old-name (slot-value r 'name))
+                (new-name (ebdb-read (eieio-object-class old-name) nil 
old-name)))
+          (ebdb-record-change-name r new-name))
        (if (eieio-object-p field)
            (ebdb-record-change-field r field)
          (message "Point not in field"))))))
diff --git a/ebdb-mua.el b/ebdb-mua.el
index c266003..3b01641 100644
--- a/ebdb-mua.el
+++ b/ebdb-mua.el
@@ -898,27 +898,11 @@ Return the records matching ADDRESS or nil."
              (mail mail) ;; possibly changed below
              (created-p created-p)
              (update-p update-p)
-            (name-slot (ignore-errors
-                         (car
-                          (ebdb-record-field-slot-query
-                           (eieio-object-class record)
-                           `(nil . ,(eieio-object-class
-                                     (ebdb-parse
-                                      (if (eql record-class 
'ebdb-record-organization)
-                                          'ebdb-field-name-simple
-                                        'ebdb-field-name-complex)
-                                      name)))))))
              change-p add-mails add-name ignore-redundant)
 
         ;; Analyze the name part of the record.
         (cond (created-p               ; new record
-               (ebdb-record-change-name
-               record
-               (ebdb-parse
-                (if (eql record-class 'ebdb-record-organization)
-                    'ebdb-field-name-simple
-                  'ebdb-field-name-complex)
-                name)))
+               (ebdb-record-change-name record name))
 
               ((or (not name)
                    ;; The following tests can differ for more complicated names
@@ -942,24 +926,25 @@ Return the records matching ADDRESS or nil."
                                          name (car (ebdb-record-mail 
record)))))
                ;; Keep old-name as AKA?
                (when (and old-name
-                         name-slot
+                         ;; Leaky abstraction
+                         (object-of-class-p record 'ebdb-record-person)
                           (not (member-ignore-case old-name 
(ebdb-record-alt-names record))))
                  (if (ebdb-eval-spec (ebdb-add-job ebdb-add-aka record 
old-name)
                                      (format "Keep name \"%s\" as an AKA? " 
old-name))
                      (ebdb-record-insert-field
-                      record name-slot (slot-value record 'name))))
-               (ebdb-record-change-name record (ebdb-parse 'ebdb-field-name 
name))
+                      record 'aka (slot-value record 'name))))
+               (ebdb-record-change-name record name)
                (setq change-p 'name))
 
               ;; make new name an AKA?
               ((and old-name
-                   name-slot
+                   (object-of-class-p record 'ebdb-record-person)
                     (not (member-ignore-case name (ebdb-record-alt-names 
record)))
                     (ebdb-eval-spec (ebdb-add-job ebdb-add-aka record name)
                                     (format "Make \"%s\" an alternate for 
\"%s\"? "
                                             name old-name)))
                (ebdb-record-insert-field
-                record name-slot (ebdb-parse 'ebdb-field-name name))
+                record 'aka (ebdb-parse 'ebdb-field-name name))
                (setq change-p 'name)))
 
         ;; Is MAIL redundant compared with the mail addresses
@@ -1013,9 +998,7 @@ Return the records matching ADDRESS or nil."
                         (progn
                           (setq record (make-instance 
ebdb-default-record-class))
                          (ebdb-db-add-record (car ebdb-db-list) record)
-                          (ebdb-record-change-name
-                          record
-                          (ebdb-parse 'ebdb-field-name name))
+                          (ebdb-record-change-name record name)
                           (setq created-p t))))
 
                (let ((mails (ebdb-record-mail record)))
diff --git a/ebdb.el b/ebdb.el
index 9a16286..dab4f98 100644
--- a/ebdb.el
+++ b/ebdb.el
@@ -1884,6 +1884,13 @@ If DB is given, only delete RECORD from DB.
 If UNLOAD is non-nil, we should only unload RECORD, not delete it
 altogether.")
 
+(cl-defgeneric ebdb-record-change-name (record name)
+  "Change RECORD's name to NAME.
+
+NAME can be an instance of `ebdb-field-name' or one of its
+subclasses, or it can be a string, in which case the class of
+RECORD is responsible for parsing it correctly.")
+
 (cl-defmethod ebdb-record-uuid ((record ebdb-record))
   (if-let ((uuid-field (slot-value record 'uuid)))
    (slot-value uuid-field 'uuid)))
@@ -2264,9 +2271,12 @@ or actual image data."
       (push `(address . ,a) f-list)))
   (cl-call-next-method record f-list all))
 
-(cl-defmethod ebdb-record-change-name ((record ebdb-record-entity) name)
+(cl-defmethod ebdb-record-change-name ((record ebdb-record-entity)
+                                      (name ebdb-field-name))
   (when (slot-value record 'name)
     (ebdb-record-delete-field record 'name (slot-value record 'name)))
+  (setf (slot-value (ebdb-record-cache record) 'name-string)
+       (ebdb-string name))
   (ebdb-record-insert-field record 'name name))
 
 (cl-defmethod ebdb-record-organizations ((_record ebdb-record-entity))
@@ -2427,15 +2437,10 @@ priority."
       (push `(organizations . ,o) f-list)))
   (cl-call-next-method record f-list all))
 
-;; TODO: Now that both people and organizations have class-based
-;; names, there's no longer any real reason to have two
-;; implementations of this method.  One implementation that accepted a
-;; `ebdb-field-name' subclass symbol would be sufficient.
-(cl-defmethod ebdb-record-change-name ((record ebdb-record-person) &optional 
name)
-  (let* ((new-name (or name (ebdb-read ebdb-default-name-class nil
-                                      (slot-value record 'name)))))
-    (setf (slot-value (ebdb-record-cache record) 'name-string) (ebdb-string 
new-name))
-    (cl-call-next-method record new-name)))
+(cl-defmethod ebdb-record-change-name ((record ebdb-record-person)
+                                      (name string))
+  (let ((new-name (ebdb-parse ebdb-default-name-class name)))
+   (cl-call-next-method record new-name)))
 
 (cl-defmethod ebdb-record-related ((_record ebdb-record-person)
                                   (field ebdb-field-relation))
@@ -2523,7 +2528,7 @@ priority."
 (defclass ebdb-record-organization (ebdb-record-entity)
   ((name
     :initarg :name
-    :type ebdb-field-name-simple
+    :type (or null ebdb-field-name-simple)
     :initform nil
     :documentation "The name of this organization.")
    (domain
@@ -2676,9 +2681,9 @@ appropriate person record."
     (when org
       (ebdb-record-adopt-role-fields record org t))))
 
-(cl-defmethod ebdb-record-change-name ((org ebdb-record-organization) 
&optional name)
-  (let ((new-name (or name (ebdb-read 'ebdb-field-name-simple nil (slot-value 
org 'name)))))
-    (setf (slot-value (ebdb-record-cache org) 'name-string) (ebdb-string 
new-name))
+(cl-defmethod ebdb-record-change-name ((org ebdb-record-organization)
+                                      (name string))
+  (let ((new-name (ebdb-parse 'ebdb-field-name-simple name)))
     (cl-call-next-method org new-name)))
 
 (cl-defmethod ebdb-record-related ((_record ebdb-record-organization)