Newer
Older
;;; eudc.el --- Emacs Unified Directory Client
;; Copyright (C) 1998 Free Software Foundation, Inc.
;; Author: Oscar Figueiredo <Oscar.Figueiredo@epfl.ch>
;; Maintainer: Oscar Figueiredo <Oscar.Figueiredo@epfl.ch>
;; Created: Feb 1998
;; Version: $Revision$
;; Keywords: help
;; This file is part of XEmacs
;; XEmacs 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 2, or (at your option)
;; any later version.
;; XEmacs 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 XEmacs; see the file COPYING. If not, write to
;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;; Commentary:
;; This package provides a common interface to query directory
;; servers using different protocols such as LDAP or CCSO PH/QI.
;; Queries can be made through an interactive form.
;; Inline query strings in buffers can also be expanded with appropriately
;; formatted query results (especially used to expand email addresses in
;; message buffers). It also interfaces with the BBDB package to let you
;; register query results into your own BBDB database.
;;; Installation:
;; This library is compatible with XEmacs 20 and under Emacs 19.34 and above
;;; Usage:
;;; Code:
(require 'wid-edit)
(eval-and-compile
(if (not (fboundp 'make-overlay))
(require 'overlay))
(if (not (fboundp 'unless))
(require 'cl)))
(autoload 'custom-menu-create "cus-edit")
(autoload 'bbdb-create-internal "bbdb-com")
(autoload 'bbdb-parse-phone-number "bbdb-com")
(autoload 'bbdb-display-records "bbdb")
;;{{{ Package customization variables
(defgroup eudc nil
"Emacs Unified Directory Client"
:group 'mail
:group 'comm)
(defcustom eudc-server nil
"*The name or IP address of the directory server.
A port number may be specified by appending a colon and a
number to the name of the server."
:type '(string :tag "Server")
:group 'eudc)
(defvar eudc-supported-protocols nil
"Protocols currently supported by the Unified Directory Client.
This variable is updated when protocol-specific libraries
(defcustom eudc-protocol nil
"*The directory protocol to use to query the server.
Supported protocols are specified by `eudc-supported-protocols'."
:type `(choice :menu-tag "Protocol"
,@(mapcar (lambda (s)
(list 'string ':tag (symbol-name s)))
eudc-supported-protocols))
:group 'eudc)
(defcustom eudc-strict-return-matches t
"*If non-nil, ignore entries that do not contain all requested return attributes."
:type 'boolean
:group 'eudc)
(defcustom eudc-default-return-attributes nil
"*A list of the default attributes to extract from directory entries.
If set to the symbol `all' return all attributes.
nil means return the default attributes as configured in the server."
:type '(choice :menu-tag "Return Attributes"
(const :menu-tag "Server Defaults (nil)" nil)
(const :menu-tag "All" all)
(repeat :menu-tag "Edit List" (symbol :tag "Field name")))
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
:group 'eudc)
(defcustom eudc-multiple-match-handling-method 'select
"*What to do when multiple entries match an inline expansion query.
Possible values are:
`first' (equivalent to nil) which means keep the first match only,
`select' pop-up a selection buffer,
`all' expands to all matches,
`abort' the operation is aborted, an error is signaled."
:type '(choice :menu-tag "Method"
(const :menu-tag "First" first)
(const :menu-tag "Select" select)
(const :menu-tag "All" all)
(const :menu-tag "Abort" abort)
(const :menu-tag "None" nil))
:group 'eudc)
(defcustom eudc-duplicate-attribute-handling-method '((email . duplicate))
"*A method to handle entries containing duplicate attributes.
This is either an alist (ATTR . METHOD) or a symbol METHOD.
The alist form of the variable associates a method to an individual attribute,
the second form specifies a method applicable to all attributes.
Available methods are:
`list' or nil lets the value of the attribute be a list of values,
`first' keeps the first value and discards the others,
`concat' concatenates the values into a single multiline string,
`duplicate' duplicates the entire entry into as many instances as
different values."
:type '(choice (const :menu-tag "List" list)
(const :menu-tag "First" first)
(const :menu-tag "Concat" concat)
(const :menu-tag "Duplicate" duplicate)
(repeat :menu-tag "Per Attribute Specification"
:tag "Per Attribute Specification"
(cons :tag "Attribute/Method"
:value (nil . list)
(symbol :tag "Attribute name")
(choice :tag "Method"
:menu-tag "Method"
(const :menu-tag "List" list)
(const :menu-tag "First" first)
(const :menu-tag "Concat" concat)
(const :menu-tag "Duplicate" duplicate)))))
:group 'eudc
)
(defcustom eudc-inline-query-format nil
"*Format of an inline expansion query.
If the inline query string consists of several words, this list specifies
how these individual words are mapped onto attribute names.
If nil all the words will be mapped onto the default server/protocol key."
:type '(repeat (symbol :tag "Attribute name"))
:group 'eudc)
(defcustom eudc-expansion-overwrites-query t
"*If non nil, expanding a query overwrites the query string."
:type 'boolean
:group 'eudc)
(defcustom eudc-inline-expansion-format '("%s" email)
"*A list specifying the format of the expansion of inline queries.
This variable controls what `eudc-expand-inline' actually inserts in the buffer.
First element is a string passed to `format'. Remaining elements are symbols
indicating attribute names, the corresponding values are passed
as additional arguments to `format'."
:type '(list (string :tag "Format String")
(repeat :inline t
:tag "Attribute names"
(symbol :tag "")))
:group 'eudc)
(defcustom eudc-query-form-attributes '(name firstname email phone)
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
"*A list of attributes presented in the query form."
:tag "Attributes in Query Forms"
:type '(repeat (symbol :tag "Attribute name"))
:group 'eudc)
(defcustom eudc-user-attribute-names-alist '((url . "URL")
(callsign . "HAM Call Sign")
(id . "ID")
(email . "E-Mail")
(firstname . "First Name")
(cn . "Full Name")
(sn . "Surname")
(givenname . "First Name")
(ou . "Unit")
(labeledurl . "URL")
(postaladdress . "Address")
(postalcode . "Postal Code")
(l . "Location")
(c . "Country")
(o . "Organization")
(roomnumber . "Office")
(telephonenumber . "Phone")
(uniqueidentifier . "ID")
(objectclass . "Object Class"))
"*Alist of user-defined names for directory attributes.
These names are used as prompt strings in query/response forms
instead of the raw directory attribute names.
Prompt strings for attributes that are not listed here
are derived by splitting the attribute name
at `_' signs and capitalizing the individual words."
:tag "User-defined Names of Directory Attributes"
:type '(repeat (cons :tag "Field"
(symbol :tag "Directory attribute")
(string :tag "User name")))
:group 'eudc)
(defcustom eudc-use-raw-directory-names nil
"*If non-nil, use attributes names as defined in the directory.
Otherwise, directory query/response forms display the user attribute
names defined in `eudc-user-attribute-names-alist'."
:type 'boolean
:group 'eudc)
(defcustom eudc-options-file "~/.eudc-options"
"*A file where the `servers' hotlist is stored."
:type '(file :Tag "File Name:"))
(defcustom eudc-mode-hook nil
"*Normal hook run on entry to EUDC mode."
:type '(repeat (sexp :tag "Hook")))
;;}}}
;;{{{ Internal cooking
;;{{{ Internal variables and compatibility tricks
(defconst eudc-xemacs-p (string-match "XEmacs" emacs-version))
(defconst eudc-emacs-p (not eudc-xemacs-p))
(defconst eudc-xemacs-mule-p (and eudc-xemacs-p
(featurep 'mule)))
(defconst eudc-emacs-mule-p (and eudc-emacs-p
(featurep 'mule)))
(defvar eudc-form-widget-list nil)
(defvar eudc-hotlist-mode-map nil)
(defvar eudc-hotlist-list-beginning nil)
;; Used by the selection insertion mechanism
(defvar eudc-pre-select-window-configuration nil)
(defvar eudc-insertion-marker nil)
;; List of known servers
;; Alist of (SERVER . PROTOCOL)
(defvar eudc-server-hotlist nil)
;; Query function
;; Protocol dependent, should be defined in eudc-protocol-locals
(defvar eudc-query-function nil)
;; A function that retrieves a list of valid attribute names
(defvar eudc-list-attributes-function nil)
;; A mapping between EUDC attribute names and corresponding
;; protocol specific names
;; The following names are defined by EUDC and may be included
(defvar eudc-protocol-attributes-translation-alist nil)
;; A function called each time EUDC switches to a protocol
(defvar eudc-protocol-switch-init-function nil)
;; A function called each time EUDC switches from a protocol to
;; another one
(defvar eudc-protocol-switch-exit-function nil)
;; Protocol locals
;; List of (PROTOCOL (EUDC-VAR . VALUE) (EUDC-VAR .VALUE) ...)
(defvar eudc-protocol-locals '((default
(eudc-query-function . nil)
(eudc-list-attributes-function . nil)
(eudc-protocol-attributes-translation-alist . nil)
(eudc-bbdb-conversion-alist . nil)
(eudc-protocol-switch-init-function . nil)
(eudc-protocol-switch-exit-function . nil))))
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
;;; Emacs does not provide that one
(if (not (fboundp 'split-string))
(defun split-string (string pattern)
"Return a list of substrings of STRING which are separated by PATTERN."
(let (parts (start 0))
(while (string-match pattern string start)
(setq parts (cons (substring string start (match-beginning 0)) parts)
start (match-end 0)))
(nreverse (cons (substring string start) parts))
)))
(defun eudc-cadr (obj)
(car (cdr obj)))
(defun eudc-cdar (obj)
(cdr (car obj)))
(defun eudc-caar (obj)
(car (car obj)))
(defun eudc-cdaar (obj)
(cdr (car (car obj))))
;;}}}
;; Add PROTOCOL to the list of supported protocols
;; and LOCALS to the protocol locals list
(defun eudc-register-protocol (protocol locals)
(unless (memq protocol eudc-supported-protocols)
(setq eudc-supported-protocols
(cons protocol eudc-supported-protocols))
(setq eudc-protocol-locals
(cons (cons protocol locals)
eudc-protocol-locals))))
(defun eudc-switch-to-protocol (protocol)
(unless (or (member protocol
eudc-supported-protocols)
(load (concat "eudc-" (symbol-name protocol)) t))
(error "Unsupported protocol: %s" protocol))
(condition-case nil
(let ((locals (assq 'default eudc-protocol-locals)))
(if eudc-protocol-switch-exit-function
(funcall eudc-protocol-switch-exit-function))
;; Reset protocol locals to their default values
(setq locals (cdr locals))
(while locals
(set (car (car locals)) (cdr (car locals)))
(setq locals (cdr locals)))
(setq locals (assq protocol eudc-protocol-locals))
(if (null locals)
(error "No protocol specific settings found"))
(setq locals (cdr locals))
(while locals
(set (car (car locals)) (cdr (car locals)))
(setq locals (cdr locals)))
(setq eudc-protocol protocol)
(if eudc-protocol-switch-init-function
(funcall eudc-protocol-switch-init-function)))
;; If something bad happens return to the previous protocol
(t
(if eudc-protocol
(eudc-switch-to-protocol eudc-protocol)))))
(defun eudc-translate-query (query)
"Translate attribute names of QUERY according to `eudc-protocol-attributes-translation-alist'."
(if eudc-protocol-attributes-translation-alist
(mapcar '(lambda (attribute)
(let ((trans (assq (car attribute)
(symbol-value eudc-protocol-attributes-translation-alist))))
(if trans
(cons (cdr trans) (cdr attribute))
attribute)))
query)
query))
(defun eudc-translate-attribute-list (list)
"Translate a list of attribute names according to `eudc-protocol-attributes-translation-alist'."
(if eudc-protocol-attributes-translation-alist
(let (trans)
(mapcar '(lambda (attribute)
(setq trans (assq attribute
(symbol-value eudc-protocol-attributes-translation-alist)))
(if trans
(cdr trans)
attribute))
list))
list))
(defun eudc-select (choices)
"Choose one from CHOICES using a completion buffer."
(setq eudc-pre-select-window-configuration (current-window-configuration))
(setq eudc-insertion-marker (point-marker))
(with-output-to-temp-buffer "*EUDC Completions*"
(display-completion-list
:activate-callback 'eudc-insert-selected)))
(defun eudc-insert-selected (event extent user)
"Insert a completion at the appropriate point."
(when eudc-insertion-marker
(set-buffer (marker-buffer eudc-insertion-marker))
(goto-char eudc-insertion-marker)
(insert (extent-string extent)))
(if eudc-pre-select-window-configuration
(set-window-configuration eudc-pre-select-window-configuration))
(setq eudc-pre-select-window-configuration nil
eudc-insertion-marker nil))
(defun eudc-query (query &optional return-attributes no-translation)
"Query the directory server with QUERY.
QUERY is a list of cons cells (ATTR . VALUE) where
ATTR is an attribute name and VALUE the corresponding
value.
ATTR is translated according to `eudc-protocol-attributes-translation-alist'
unless NO-TRANSLATION is non nil.
RETURN-ATTRIBUTES is a list of attributes to return,
defaulting to `eudc-default-return-attributes'."
(unless eudc-query-function
(error "Don't know how to perform the query"))
(if no-translation
(funcall eudc-query-function query (or return-attributes
eudc-default-return-attributes))
(funcall eudc-query-function
(eudc-translate-query query)
(eudc-translate-attribute-list (or return-attributes
eudc-default-return-attributes)))))
(defun eudc-display-records (records &optional raw-attr-names)
"Display the record list RECORDS in a formatted buffer.
If RAW-ATTR-NAMES is non-nil, the raw attribute names are displayed
otherwise they are formatted according to `eudc-user-attribute-names-alist'."
(let ((buffer (get-buffer-create "*Directory Query Results*"))
inhibit-read-only
precords
(width 0)
beg field-beg
attribute)
(switch-to-buffer buffer)
(setq buffer-read-only t)
(setq inhibit-read-only t)
(erase-buffer)
(insert "Directory Query Result\n")
(insert "======================\n\n\n")
(if (null records)
(insert "No match found.\n"
(if eudc-strict-return-matches
"Try setting `eudc-strict-return-matches' to nil or change `eudc-default-return-attributes'.\n"
""))
(setq precords
(mapcar
(function
(lambda (record)
(mapcar
(function
(lambda (field)
(setq attribute (if raw-attr-names
(symbol-name (car field))
(or (and (assq (car field) eudc-user-attribute-names-alist)
(capitalize (mapconcat '(lambda (char)
(if (eq char ?_)
" "
(char-to-string char)))
(symbol-name (car field))
"")))))
(if (> (length attribute) width)
(setq width (length attribute)))
(cons attribute (cdr field))))
record)))
records))
(mapcar (function
(lambda (record)
(setq beg (point))
;; Actually insert the attribute/value pairs
(mapcar (function
(lambda (field)
(setq field-beg (point))
(insert (format (concat "%" (int-to-string width) "s: ") (car field)))
(put-text-property field-beg (point) 'face 'bold)
(mapcar (function
(lambda (val)
(indent-to (+ 2 width))
(insert val "\n")))
(cond
((stringp (cdr field))
(split-string (cdr field) "\n"))
((null (cdr field))
'(""))
(t
(cdr field))))))
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
record)
;; Store the record internal format in some convenient place
(overlay-put (make-overlay beg (point))
'eudc-record
(car records))
(setq records (cdr records))
(insert "\n")))
precords))
(insert "\n")
(widget-create 'push-button
:notify (lambda (&rest ignore)
(eudc-query-form))
"New query")
(widget-insert " ")
(widget-create 'push-button
:notify (lambda (&rest ignore)
(kill-this-buffer))
"Quit")
(eudc-mode)
(widget-setup)
)
)
(defun eudc-process-form ()
"Process the query form in current buffer and display the results."
(let (query-alist
value)
(if (not (and (boundp 'eudc-form-widget-list)
eudc-form-widget-list))
(error "Not in a directory query form buffer")
(mapcar (function
(lambda (wid-field)
(setq value (widget-value (cdr wid-field)))
(if (not (string= value ""))
(setq query-alist (cons (cons (car wid-field) value)
query-alist)))))
eudc-form-widget-list)
(kill-buffer (current-buffer))
(eudc-display-records (eudc-query query-alist) eudc-use-raw-directory-names)
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
)))
(defun eudc-filter-duplicate-attributes (record)
"Filter RECORD according to `eudc-duplicate-attribute-handling-method'."
(let ((rec record)
unique
duplicates
result)
;; Search for multiple records
(while (and rec
(not (listp (eudc-cdar rec))))
(setq rec (cdr rec)))
(if (null (eudc-cdar rec))
(list record) ; No duplicate attrs in this record
(mapcar (function
(lambda (field)
(if (listp (cdr field))
(setq duplicates (cons field duplicates))
(setq unique (cons field unique)))))
record)
(setq result (list unique))
(mapcar (function
(lambda (field)
(let ((method (if (consp eudc-duplicate-attribute-handling-method)
(cdr (assq (car field) eudc-duplicate-attribute-handling-method))
eudc-duplicate-attribute-handling-method)))
(cond
((or (null method) (eq 'list method))
(setq result
(eudc-add-field-to-records field result)))
((eq 'first method)
(setq result
(eudc-add-field-to-records (cons (car field) (eudc-cadr field)) result)))
((eq 'concat method)
(setq result
(eudc-add-field-to-records (cons (car field)
(mapconcat
'identity
(cdr field)
"\n")) result)))
((eq 'duplicate method)
(setq result
(eudc-distribute-field-on-records field result)))))))
duplicates)
result)))
(defun eudc-filter-partial-records (records attrs)
"Eliminate records that do not caontain all ATTRS from RECORDS."
(delq nil
(mapcar
(function
(lambda (rec)
(if (eval (cons 'and
(mapcar
(function
(lambda (attr)
(consp (assq attr rec))))
attrs)))
rec)))
records)))
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
(defun eudc-add-field-to-records (field records)
"Add FIELD to each individual record in RECORDS and return the resulting list."
(mapcar (function
(lambda (r)
(cons field r)))
records))
(defun eudc-distribute-field-on-records (field records)
"Duplicate each individual record in RECORDS according to value of FIELD.
Each copy is added a new field containing one of the values of FIELD."
(let (result
(values (cdr field)))
;; Uniquify values first
(while values
(setcdr values (delete (car values) (cdr values)))
(setq values (cdr values)))
(mapcar (function
(lambda (value)
(let ((result-list (copy-sequence records)))
(setq result-list (eudc-add-field-to-records (cons (car field) value)
result-list))
(setq result (append result-list result))
)))
(cdr field))
result)
)
(defun eudc-create-bbdb-record (record)
"Create a BBDB record using the RECORD alist.
RECORD is an alist of (KEY . VALUE) where KEY is a directory attribute name
symbol and VALUE is the corresponding value for the record."
;; This function runs in a special context where lisp symbols corresponding
;; to field names in record are bound to the corresponding values
(eval
`(let* (,@(mapcar '(lambda (c)
(list (car c) (if (listp (cdr c))
(list 'quote (cdr c))
(cdr c))))
record)
bbdb-name
bbdb-company
bbdb-net
bbdb-address
bbdb-phones
bbdb-notes
spec
bbdb-record
value
(conversion-alist (symbol-value eudc-bbdb-conversion-alist)))
;; BBDB standard fields
(setq bbdb-name (eudc-parse-spec (cdr (assq 'name conversion-alist)) record nil)
bbdb-company (eudc-parse-spec (cdr (assq 'company conversion-alist)) record nil)
bbdb-net (eudc-parse-spec (cdr (assq 'net conversion-alist)) record nil)
bbdb-notes (eudc-parse-spec (cdr (assq 'notes conversion-alist)) record nil))
(setq spec (cdr (assq 'address conversion-alist)))
(setq bbdb-address (delq nil (eudc-parse-spec (if (listp (car spec))
spec
(list spec))
record t)))
(setq spec (cdr (assq 'phone conversion-alist)))
(setq bbdb-phones (delq nil (eudc-parse-spec (if (listp (car spec))
spec
(list spec))
record t)))
;; BBDB custom fields
(setq bbdb-notes (append (list (and bbdb-notes (cons 'notes bbdb-notes)))
(mapcar (function
(lambda (mapping)
(if (and (not (memq (car mapping)
'(name company net address phone notes)))
(setq value (eudc-parse-spec (cdr mapping) record nil)))
(cons (car mapping) value))))
conversion-alist)))
(setq bbdb-notes (delq nil bbdb-notes))
(setq bbdb-record (bbdb-create-internal bbdb-name
bbdb-company
bbdb-net
bbdb-address
bbdb-phones
bbdb-notes))
(bbdb-display-records (list bbdb-record))
)))
(defun eudc-parse-spec (spec record recurse)
"Parse the conversion SPEC using RECORD.
If RECURSE is non-nil then SPEC may be a list of atomic specs."
(cond
((or (stringp spec)
(symbolp spec)
(and (listp spec)
(symbolp (car spec))
(fboundp (car spec))))
(condition-case nil
(eval spec)
(void-variable nil)))
((and recurse
(listp spec))
(mapcar '(lambda (spec-elem)
(eudc-parse-spec spec-elem record nil))
spec))
(t
(error "Invalid specification for `%s' in `eudc-bbdb-conversion-alist'" spec))))
(defun eudc-bbdbify-address (addr location)
"Parse ADDR into a vector compatible with BBDB.
ADDR should be an address string of no more than four lines or a
list of lines.
The last two lines are searched for the zip code, city and state name.
LOCATION is used as the address location for bbdb."
(let* ((addr-components (if (listp addr)
(reverse addr)
(reverse (split-string addr "\n"))))
(last1 (pop addr-components))
(last2 (pop addr-components))
zip city state)
(setq addr-components (nreverse addr-components))
;; If not containing the zip code the last line is supposed to contain a
;; country name and the addres is supposed to be in european style
(if (not (string-match "[0-9][0-9][0-9]" last1))
(progn
(setq state last1)
(if (string-match "\\([0-9]+\\)[ \t]+\\(.*\\)" last2)
(setq city (match-string 2 last2)
zip (string-to-number (match-string 1 last2)))
(error "Cannot parse the address")))
(cond
;; American style
((string-match "\\(\\w+\\)\\W*\\([A-Z][A-Z]\\)\\W*\\([0-9]+\\)" last1)
(setq city (match-string 1 last1)
state (match-string 2 last1)
zip (string-to-number (match-string 3 last1))))
;; European style
((string-match "\\([0-9]+\\)[ \t]+\\(.*\\)" last1)
(setq city (match-string 2 last1)
zip (string-to-number (match-string 1 last1))))
(t
(error "Cannot parse the address"))))
(vector location
(or (nth 0 addr-components) "")
(or (nth 1 addr-components) "")
(or (nth 2 addr-components) "")
(or city "")
(or state "")
zip)))
(defun eudc-bbdbify-phone (phone location)
"Parse PHONE into a vector compatible with BBDB.
PHONE is either a string supposedly containing a phone number or
a list of such strings which are concatenated.
LOCATION is used as the phone location for BBDB."
(cond
((stringp phone)
(let (phone-list)
(condition-case err
(setq phone-list (bbdb-parse-phone-number phone))
(error
(if (string= "phone number unparsable." (eudc-cadr err))
(if (not (y-or-n-p (format "BBDB claims %S to be unparsable--insert anyway? " phone)))
(error "Phone number unparsable")
(setq phone-list (list (bbdb-string-trim phone))))
(signal (car err) (cdr err)))))
(if (= 3 (length phone-list))
(setq phone-list (append phone-list '(nil))))
(apply 'vector location phone-list)))
((listp phone)
(vector location (mapconcat 'identity phone ", ")))
(t
(error "Invalid phone specification"))))
(defun eudc-mode ()
"Major mode used in buffers displaying the results of directory queries.
There is no sense in calling this command from a buffer other than
one containing the results of a directory query.
These are the special commands of EUDC mode:
q -- Kill this buffer.
f -- Display a form to query the current directory server.
n -- Move to next record.
p -- Move to previous record.
b -- Insert record at point into the BBDB database."
(interactive)
(kill-all-local-variables)
(setq major-mode 'eudc-mode)
(setq mode-name "EUDC")
(use-local-map eudc-mode-map)
(setq mode-popup-menu (eudc-menu))
(run-hooks 'eudc-mode-hook)
)
(defun eudc-hotlist-mode ()
"Major mode used to edit the hotlist of servers.
These are the special commands of this mode:
a -- Add a new server to the list.
d -- Delete the server at point from the list.
s -- Select the server at point.
t -- Transpose the server at point and the previous one
q -- Commit the changes and quit.
x -- Quit without commiting the changes."
(interactive)
(kill-all-local-variables)
(setq major-mode 'eudc-hotlist-mode)
(setq mode-name "EUDC-Servers")
(use-local-map eudc-hotlist-mode-map)
(setq mode-popup-menu eudc-hotlist-menu)
(setq buffer-read-only t))
;;}}}
;;{{{ High-level interfaces (interactive functions)
(defun eudc-customize ()
"Customize the EUDC package."
(interactive)
(customize-group 'eudc))
(defun eudc-set-server (server protocol &optional no-save)
"Set the directory server to SERVER using PROTOCOL.
If NO-SAVE is nil, the server is saved as the default server
for future sessions."
(interactive "sDirectory Server: \nSProtocol: ")
(unless (eq protocol eudc-protocol)
(eudc-switch-to-protocol protocol))
(setq eudc-server server)
(if (interactive-p)
(message "Current directory server is now %s (%s)" eudc-server eudc-protocol))
(if (null no-save)
(eudc-save-options)))
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
;;;###autoload
(defun eudc-get-email (name)
"Get the email field of NAME from the directory server."
(interactive "sName: ")
(or eudc-server
(call-interactively 'eudc-set-server))
(let ((result (eudc-query (list (cons 'name name)) '(email)))
email)
(if (null (cdr result))
(setq email (eudc-cdaar result))
(error "Multiple match. Use the query form"))
(if (interactive-p)
(if email
(message "%s" email)
(error "No record matching %s" name)))
email))
;;;###autoload
(defun eudc-get-phone (name)
"Get the phone field of NAME from the directory server."
(interactive "sName: ")
(or eudc-server
(call-interactively 'eudc-set-server))
(let ((result (eudc-query (list (cons 'name name)) '(phone)))
phone)
(if (null (cdr result))
(setq phone (eudc-cdaar result))
(error "Multiple match. Use the query form"))
(if (interactive-p)
(if phone
(message "%s" phone)
(error "No record matching %s" name)))
phone))
(defun eudc-get-attribute-list ()
"Return a list of valid attributes for the current server.
When called interactively the list is formatted in a dedicated buffer
otherwise a list of symbols is returned."
(interactive)
(if eudc-list-attributes-function
(let ((entries (funcall eudc-list-attributes-function (interactive-p))))
(if entries
(if (interactive-p)
(eudc-display-records entries t)
entries)))
(error "The %s protocol has no support for listing attributes" eudc-protocol)))
;;;###autoload
(defun eudc-expand-inline (&optional replace)
"Query the directory server, and expand the query string before point.
The query string consists of the buffer substring from the point back to
the preceding comma, colon or beginning of line.
The variable `eudc-inline-query-format' controls how to associate the
individual inline query words with directory attribute names.
After querying the server for the given string, the expansion specified by
`eudc-inline-expansion-format' is inserted in the buffer at point.
If REPLACE is non nil, then this expansion replaces the name in the buffer.
`eudc-expansion-overwrites-query' being non nil inverts the meaning of REPLACE."
(interactive)
(or eudc-server
(call-interactively 'eudc-set-server))
(let* ((end (point))
(beg (save-excursion
(if (re-search-backward "[:,][ \t]*"
(save-excursion
(beginning-of-line)
(point))
'move)
(goto-char (match-end 0)))
(point)))
(words (buffer-substring beg end))
query
query-alist
(query-format eudc-inline-query-format)
(eudc-inline-expansion-format
(cons (car eudc-inline-expansion-format)
(eudc-translate-attribute-list
(cdr eudc-inline-expansion-format))))
response-strings
key val cell)
;; Prepare the query
(setq query words)
(setq words (split-string words "[ \t]+"))
(while (and words query-format)
(setq query-alist (cons (cons (car query-format) (car words)) query-alist))
(setq words (cdr words)
query-format (cdr query-format)))
;; If the same attribute appears more than once, merge
;; the corresponding values
(setq query-alist (nreverse query-alist))
(while query-alist
(setq key (eudc-caar query-alist)
val (eudc-cdar query-alist)
cell (assq key query))
(if cell
(setcdr cell (concat val " " (cdr cell)))
(setq query (cons (car query-alist) query)))
(setq query-alist (cdr query-alist))))
(setq response (eudc-query query (cdr eudc-inline-expansion-format)))
(if (null response)
(error "No match found")
;; Process response through eudc-inline-expansion-format
(while response
(setq response-string (apply 'format
(car eudc-inline-expansion-format)
(mapcar (function
(lambda (field)
(or (cdr (assq field (car response)))
"")))
(cdr eudc-inline-expansion-format))))
(if (> (length response-string) 0)
(setq response-strings
(cons response-string response-strings)))
(setq response (cdr response)))
(if (or
(and replace (not eudc-expansion-overwrites-query))
(and (not replace) eudc-expansion-overwrites-query))
(delete-region beg end))
(cond
((or (= (length response-strings) 1)
(null eudc-multiple-match-handling-method)
(eq eudc-multiple-match-handling-method 'first))
(insert (car response-strings)))
((eq eudc-multiple-match-handling-method 'select)
((eq eudc-multiple-match-handling-method 'all)
(insert (mapconcat 'identity response-strings ", ")))
((eq eudc-multiple-match-handling-method 'abort)
(error "There is more than one match for the query"))
))
)
)
;;;###autoload
(defun eudc-query-form (&optional get-fields-from-server)
"Display a form to query the directory server.
If given a non-nil argument the function first queries the server
for the existing fields and displays a corresponding form."
(interactive "P")
(let ((fields (or (and get-fields-from-server
(eudc-get-attribute-list))
eudc-query-form-attributes))
(buffer (get-buffer-create "*Directory Query Form*"))
widget
(width 0)
inhibit-read-only
pt)
(switch-to-buffer buffer)
(setq inhibit-read-only t)
(erase-buffer)
(kill-all-local-variables)
(make-local-variable 'eudc-form-widget-list)
(widget-insert "Directory Query Form\n")
(widget-insert "====================\n\n")
(widget-insert "Current server is: " (or eudc-server
(progn
(call-interactively 'eudc-set-server)
eudc-server))
"\n")
(widget-insert "Protocol : " (symbol-name eudc-protocol) "\n")
;; Build the list of prompts
(setq prompts (if eudc-use-raw-directory-names
(mapcar 'symbol-name (eudc-translate-attribute-list fields))
(mapcar (function
(lambda (field)
(or (and (assq field eudc-user-attribute-names-alist)
(cdr (assq field eudc-user-attribute-names-alist)))
(capitalize (symbol-name field)))))
fields)))
;; Loop over prompt strings to find the longest one
(mapcar (function
(lambda (prompt)
(if (> (length prompt) width)
(setq width (length prompt)))))
prompts)
;; Insert the first widget out of the mapcar to leave the cursor
;; in the first field