(defun wg-buffer-name (buffer-or-name)

  "Return BUFFER-OR-NAME's `buffer-name', or error."

  (buffer-name (wg-get-buffer buffer-or-name)))

(defun wg-buffer-file-name (buffer-or-name)

  "Return BUFFER-OR-NAME's `buffer-file-name', or error."

  (buffer-file-name (wg-get-buffer buffer-or-name)))

(defun wg-buffer-major-mode (buffer-or-name)

  "Return BUFFER's major-mode."

  (with-current-buffer buffer-or-name major-mode))

(defun wg-current-buffer-p (buffer-or-name)

  "Return t if BUFFER-OR-NAME is the current buffer, nil otherwise."

  (eq (wg-get-buffer buffer-or-name) (current-buffer)))

(defmacro wg-buffer-local-setq (buffer var value)

  "`setq' VAR to VALUE while BUFFER is current.

Note that this won't make VAR buffer-local if it isn't already."

  `(with-current-buffer ,buffer (setq ,var ,value)))

(defun wg-interesting-buffers ()

  "Return a list of only the interesting buffers in `buffer-list'."

  (cl-remove-if (lambda (bname) (string-match "^ " bname))

                (buffer-list) :key 'buffer-name))

(defun wg-get-first-buffer-matching-regexp (regexp &optional buffer-list)

  "Return the first buffer in BUFFER-LIST with a name matching REGEXP.

BUFFER-LIST should contain buffer objects and/or buffer names."

  (cl-find regexp (or buffer-list (buffer-list))

           :test 'string-match :key 'wg-buffer-name))

;;; files

(defun wg-write-sexp-to-file (sexp file)

  "Write the printable representation of SEXP to FILE."

  (with-temp-buffer

    (let ((print-level nil)  (print-length nil))

      (insert (format "%S" sexp)))

    (write-file file)))

(defun wg-read-sexp-from-file (file)

  "Return a Lisp object from FILE."

  (with-temp-buffer

    (insert-file-contents file)

    (goto-char (point-min))

    (read (current-buffer))))

(defalias 'wg-lisp-object-from-file 'wg-read-sexp-from-file)

(defun wg-file-under-root-path-p (root-path file-path)

  "Return t when FILE-PATH is under ROOT-PATH, nil otherwise."

  (string-match (concat "^" (regexp-quote (expand-file-name root-path)))

                (expand-file-name file-path)))

;;; frames

(defun wg-cyclic-nth-from-frame (&optional n frame)

  "Return the frame N places away from FRAME in `frame-list' cyclically.

N defaults to 1, and FRAME defaults to `selected-frame'."

  (wg-cyclic-nth-from-elt

   (or frame (selected-frame)) (frame-list) (or n 1)))

;;; namespace-prefixed defstruct

(defmacro wg-defstruct (prefix name-form &rest slot-defs)

  "`defstruct' wrapper that namespace-prefixes all generated functions.

Note: this doesn't yet work with :conc-name, and possibly other

options."

  (declare (indent 2))

  (let* ((name (if (consp name-form) (car name-form) name-form))

         (prefixed-name (wg-symcat prefix "-" name)))

    (cl-labels ((rebind (opstr)

                      (let ((oldfnsym (wg-symcat opstr "-" prefix "-" name)))

                        `((fset ',(wg-symcat prefix "-" opstr "-" name)

                                (symbol-function ',oldfnsym))

                          (fmakunbound ',oldfnsym)))))

      ;; `eval-and-compile' gets rid of byte-comp warnings ("function `foo' not

      ;; known to be defined").  We can accomplish this with `declare-function'

      ;; too, but it annoyingly requires inclusion of the function's arglist,

      ;; which gets ugly.

      `(eval-and-compile

         (cl-defstruct ,(if (symbolp name-form) prefixed-name

                       `(,prefixed-name ,@(cdr name-form)))

           ,@slot-defs)

         ,@(rebind "make")

         ,@(rebind "copy")

         ',prefixed-name))))

(defmacro wg-with-slots (obj slot-bindings &rest body)

  "Bind OBJ's slot values to symbols in BINDS, then eval BODY.

The car of each element of SLOT-BINDINGS is the bound symbol, and

the cadr as the accessor function."

  (declare (indent 2))

  (wg-with-gensyms (objsym)

    `(let* ((,objsym ,obj)

            ,@(wg-docar (slot slot-bindings)

                `(,(car slot) (,(cadr slot) ,objsym))))

       ,@body)))

;;; misc

(defun wg-minibuffer-inactive-p ()

  "Return t when `minibuffer-depth' returns zero, nil otherwise."

  (zerop (minibuffer-depth)))

(defun wg-minibuffer-active-p ()

  "Return t when `minibuffer-depth' does not return zero, nil otherwise."

  (not (wg-minibuffer-inactive-p)))

(defun wg-fill-keymap (keymap &rest binds)

  "Return KEYMAP after defining in it all keybindings in BINDS."

  (while binds

    (define-key keymap (car binds) (cadr binds))

    (setq binds (cddr binds)))

  keymap)

(defun wg-add-or-remove-hooks (remove &rest pairs)

  "Add FUNCTION to or remove it from HOOK, depending on REMOVE."

  (dolist (pair (wg-partition pairs 2))

    (funcall (if remove 'remove-hook 'add-hook)

             (car pair) (cadr pair))))

(defun wg-read-object (prompt test warning &optional initial-contents keymap

                              read hist default-value inherit-input-method)

  "PROMPT for an object that satisfies TEST, WARNING if necessary.

ARGS are `read-from-minibuffer's args, after PROMPT."

  (cl-labels ((read () (read-from-minibuffer

                      prompt initial-contents keymap read hist

                      default-value inherit-input-method)))

    (let ((obj (read)))

      (when (and (equal obj "") default-value) (setq obj default-value))

      (while (not (funcall test obj))

        (message warning)

        (sit-for wg-minibuffer-message-timeout)

        (setq obj (read)))

      obj)))

(defvar wg-readable-types

  '(integer float cons symbol vector string char-table bool-vector)

  "List of types with readable printed representations.")

(defun wg-is-readable-p (obj)

  "Return non-nil if OBJ's printed representation is readable."

  (memq (type-of obj) wg-readable-types))

(defun wg-take-until-unreadable (list)

  "Return a new list of elements of LIST up to the first unreadable element."

  (wg-take-until-fail 'wg-is-readable-p list))

(defun wg-add-face (facekey string)

  "Return a copy of STRING fontified according to FACEKEY.

FACEKEY must be a key in `wg-face-abbrevs'."

  (let ((face (wg-aget wg-face-abbrevs facekey))

        (string  (copy-sequence string)))

    (unless face (error "No face with key %s" facekey))

    (if (not wg-use-faces) string

      (put-text-property 0 (length string) 'face face string)

      string)))

(defmacro wg-fontify (&rest specs)

  "A small fontification DSL.

The results of all SPECS are `concat'd together.

If a spec is a cons with a keyword car, apply `wg-add-face' to it.

Other conses get evaluated, and should produce a strings.

If a spec is a string it is used unmodified.

Anything else is formatted with %s to produce a string."

  (declare (indent defun))

  `(concat

    ,@(wg-docar (spec specs)

        (cond ((and (consp spec)

                    (keywordp (car spec)))

               `(wg-add-face ,@spec))

              ;;((listp spec) (cdr (eval spec)))

              ;;((listp spec)

              ;; ;;(prin1-to-string (nth 1 (eval spec)))

              ;; )

              ((consp spec) spec)

              ((stringp spec) spec)

              (t `(format "%s" ,spec))))))

(defun wg-barf-on-active-minibuffer ()

  "Throw an error when the minibuffer is active."

  (when (wg-minibuffer-active-p)

(defmacro wg-set-parameter (place parameter value)

  "Set PARAMETER to VALUE at PLACE.

This needs to be a macro to allow specification of a setf'able place."

  (wg-with-gensyms (p v)

    `(let ((,p ,parameter) (,v ,value))

       (wg-pickelable-or-error ,p)

       (wg-pickelable-or-error ,v)

       (setf ,place (wg-aput ,place ,p ,v))

       ,v)))

;;; uid utils

(defun wg-time-to-b36 (&optional time)

  "Convert `current-time' into a b36 string."

  (apply 'concat (wg-docar (time (or time (current-time)))

                   (wg-int-to-b36 time 4))))

(defun wg-b36-to-time (b36)

  "Parse the time from UID."

  (cl-loop for i from 0 to 8 by 4

           collect (wg-b36-to-int (cl-subseq b36 i (+ i 4)))))

(defalias 'wg-uid-to-time 'wg-b36-to-time)

(defun wg-generate-uid (&optional prefix)

  "Return a new uid, optionally prefixed by PREFIX."

  (concat prefix

          (wg-time-to-b36)

          "-"

          (wg-int-to-b36 string-chars-consed)))

(defun wg-uid-to-seconds (uid)

  "Return the `float-time' parsed from UID with `wg-uid-to-time'."

  (float-time (wg-uid-to-time uid)))

(provide 'workgroups-utils-basic)

;;; workgroups-utils-basic.el ends here