;; elisp-dep-block >>
(require 'time-date);(seconds-to-time)
(require 'url);(url-mark-buffer-as-dead url-retrieve)
(require 'url-auth);(url-register-auth-scheme)
(require 'url-cache);(url-cache-extract url-cache-create-filename url-store-in-cache)
(require 'url-http);(url-http-handle-authentication url-http-mark-connection-as-free url-http-debug)
;; elisp-dep-block <<

(defconst unity-version 0.18)

(defvar unity-username nil)
(defvar unity-password nil)
(defvar unity-base-url
  "http://www.chiark.greenend.org.uk/~robh/unity/unity.cgi")

(defvar unity-fetching-url nil)
(defvar unity-edit-data    nil
  "An alist of alists: the top level keys are the classes of data
\(currently values and texts\) which are associated with an alist
of name/value pairs for that class of item.")
(make-variable-buffer-local 'unity-edit-data)
(put 'unity-edit-data 'permanent-local t)

(defvar unity-twin-buffers nil
  "A list of buffers that should be killed when this buffer is killed.")
(make-variable-buffer-local 'unity-twin-buffers)
(put 'unity-twin-buffers 'permanent-local t)

(defcustom unity-electric-comments nil
  "Whether to use the magic comment insertion function bound to \"<\""
  :type '(boolean))

(defadvice read-string (around unity-ui activate)
  "A little hackery to make the user name and password prompts from the
url libraries behave according to the unity.el convention that \"foo bar\"
is equivalent to its camel-cased form."
  (when unity-fetching-url
    (ad-set-arg 1 (or unity-username (user-full-name)))
    (ad-set-arg 3 (or unity-username (user-full-name))))
  (let ((p (ad-get-arg 0)) (flag unity-fetching-url) (unity-fetching-url nil))
    (if (and flag (string-match "user" p))
        (setq ad-return-value (unity-default-user))
      ad-do-it))
  (when unity-fetching-url
    (setq ad-return-value (unity-uglify-string ad-return-value)))
  ad-return-value)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; statistics
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun unity-mean (numbers)
  "Return the mean of NUMBERS (a list). For convenience, an empty list
will elicit a response of 0."
  (if numbers (/ (apply '+ (mapcar 'float numbers)) (length numbers)) 0))

(defun unity-sample-variance (values)
  "Calculate the \(bias corrected\) sample variance for VALUES.
For reasons of convenience, we will return 0 for empty lists or lists
consisting of 1 item."
  (let ( (mu (unity-mean values))
	 (j  (float (- (length values) 1))) )
    (if (memq j '(0 -1)) 0 ;; unsafe operation, return 0
      (/ (apply '+
		(mapcar (lambda (N) (expt (- (float N) mu) 2)) values)) j)) ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; string munging
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun unity-uglify-string (string)
  "Take a \"foo bar\" or \"foo_bar\" string and return its wiki word form."
    (apply 'concat
           (split-string (upcase-initials string) "[ _]+")) )

(defun unity-fix-string (string)
  "Take a wiki word and expand into something readable."
  (let ((case-fold-search nil))
    (replace-regexp-in-string
     "\\([a-z]\\)\\([A-Z]\\)" "\\1 \\2" string :fixed-case) ))

(defun unity-timestamp (time)
  "Return TIME (a string or integer representing a time_t) as a timestamp."
  (format-time-string
   "%Y-%m-%d %H:%M:%S"
   (cond ((stringp  time) (seconds-to-time (string-to-number time)))
	 ((integerp time) (seconds-to-time time))
	 (t               (current-time))) ) )

(defun unity-query-encode (string-list)
  (mapcar
   (lambda (S)
     (replace-regexp-in-string
      "[^A-Za-z_0-9.\/-]"
      (lambda (C) (if (equal C " ") "+" (format "%%%02x" (string-to-char C))))
      (encode-coding-string S 'utf-8 t) :fixed-case :literal)) string-list))

(defun unity-strip-tags (string)
  "Strip <> tags from a copy of STRING and return it."
  (replace-regexp-in-string "<[^>]+>" "" string))

(defun unity-compact-string (string)
  (replace-regexp-in-string "^\\s-+" "" string))

(defun unity-strip-markup (string)
  (replace-regexp-in-string "'''?\\|[][]" "" string))

(defun unity-trim-whitespace (string)
  (replace-regexp-in-string "^\\s-*\\|\\s-*$" "" string))

(defun unity-join (sep list)
  (mapconcat 'identity list sep))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; unity widget creation/destruction
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defconst unity-sep-props
  (list 'rear-nonsticky t
	'read-only      t
	'fontified      t
	'intangible     t
	'face           'mode-line))

(defun unity-text-section (text-cons)
  "Given a (name . value) cons TEXT-CONS, insert a unity text edit section
into the current buffer."
  (let ((name (car text-cons))
	(data (cdr text-cons))
	(beg              nil)
	(end              nil)
	(len              nil))
    (setq beg (format "\n<%s> \n" (upcase name))
	  end (format "\n</%s>\n" (upcase name))
	  len (length end))
    (if (= (length data) 0) (setq data " "))
    (put-text-property (- len 1) len 'unity-text-beg name beg)
    (put-text-property 0         1   'unity-text-end name end)
    (mapcar (lambda (str)
	      (add-text-properties 0 len unity-sep-props str)
	      (put-text-property 0         1   'face nil str)
	      (put-text-property (- len 1) len 'face nil str))
	    (list beg end))
    (insert beg data end) ))

(defun unity-kill-related ()
  "Kill any secondary buffers that shouldn't exist once this buffer is gone.
Targets are the buffers in `unity-twin-buffers'."
  (let ((B unity-twin-buffers) (C (current-buffer)))
    (setq unity-twin-buffers nil) ;; just in case of circular relationship.
    (while B
      (set-buffer  (car B))
      (bury-buffer)
      (kill-buffer (car B))
      (setq    B   (cdr B)))
    (set-buffer C) ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; unity and http buffer parsing (see also: table helper functions)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun unity-parse-buffer ()
  "Grab the new savetext and graveyard values from the current buffer,
load them into a ((name .value) ...) alist and return it."
  (let ((beg  nil)
	(end  nil)
	(val  nil)
	(name nil)
	(data nil))
    (save-excursion
      (setq end (point-min))
      (while (setq beg (next-single-property-change end 'unity-text-beg))
	(setq name (get-text-property beg 'unity-text-beg)
	      end  (next-single-property-change beg 'unity-text-end)
	      val  (buffer-substring (+ 1 beg) end)
	      val  (if (string-match "\\S-" val) val "")
	      data (cons (cons name val) data)) ))
    data))

(defun unity-zap-invisible ()
  "Remove text marked as \'invisible from the current buffer."
  (save-excursion
    (let ((x (point-min)) (y nil))
      (while (setq x (next-single-property-change x 'invisible))
	(when (get-text-property x 'invisible)
	  (setq y (or (next-single-property-change x 'invisible)
		      (point-max)))
	(delete-region x y) )) )) )

(defun unity-grep-values (beg end)
  "Trawl through the current buffer between BEG and END, extract any
<input> values and return an ((name . value) ...) style alist of them."
  (let ((values nil) (name nil) (val nil) (x nil) (y nil))
    (save-excursion
      (goto-char beg)
      (while (setq y (search-forward-regexp "<input[^>]+>" end t))
        (setq x (match-beginning 0))
        (goto-char x)
        (search-forward-regexp "name\\s-*=\\s-*\"\\([^\"]*\\)\""  y t)
        (if (setq name (match-string 1))
            (setq name (decode-coding-string name 'utf-8)))
        (goto-char x)
        (search-forward-regexp "value\\s-*=\\s-*\"\\([^\"]*\\)\"" y t)
        (if (setq val (match-string 1))
            (setq val (decode-coding-string val 'utf-8)))
        (if name (setq values (cons (cons name val) values))))
      values)))

(defun unity-grep-texts (beg end)
  "Trawl through the current buffer between BEG and END, extract any
<textarea> values and return an ((name . value) ...) style alist of them."
  (let ((texts nil) (name nil) (val nil) (x nil) (y nil))
    (save-excursion
      (goto-char beg)
      (while
          (setq x
                (search-forward-regexp
                 "<textarea[^>]+name\\s-*=\\s-*\"\\([^\"]*\\)\"[^>]+>" end t))
        (setq name (decode-coding-string (match-string 1) 'utf-8))
        ;;(message "found %s" name)
        (search-forward "</textarea" end)
        (setq y     (match-beginning                  0)
              val   (decode-coding-string
                     (buffer-substring-no-properties x y) 'utf-8)
              texts (cons (cons name val) texts)) ))
    texts))

(defconst unity-xlink-regex
  "\\<\\([a-zA-Z]+\\(?:[A-Z][a-z]+\\)+\\)\\>\\|\\[\\(.+?\\)\\]")

(defun unity-target-at-point (point)
  "Return the string surrounding POINT if it is a wiki link, or nil."
  (save-excursion
    (let ((end nil) (x t) (target nil) (case-fold-search nil))
      (end-of-line)
      (setq end (point))
      (beginning-of-line)
      ;; search forwards till we find an xref that spans point:
      (while (and x (search-forward-regexp unity-xlink-regex end :no-error))
	(and (<= (or (match-beginning 1) (1- (match-beginning 2))) point)
	     (>= (or (match-end       1)     (match-end       2) ) point)
	     (setq x nil target (or (match-string 1) (match-string 2)))))
      ;; make sure we don't match [[macros]]
      (if (and target (eq (aref target 0) ?\[)) nil target)) ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; unity http request and callback functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun unity-fetch (url callback &optional cbargs)
  "Fetch a unity page for editing. URL may be a string or a preparsed
url vector. CALLBACK is the function to call in the response buffer
once the response has been received and inserted into it. CBARGS is
a list of arguments to be passed to the callback function."
  (let ((url-registered-auth-schemes url-registered-auth-schemes)
        (url-passwd-entry-func      'unity-default-pass)
	(unity-fetching-url          t)
	(data-buffer                 nil))
    (url-do-setup)
    (url-register-auth-scheme "basic" 'url-basic-auth 5)
    (message "url-registered-auth-schemes:\n%S"
	     url-registered-auth-schemes)
    (setq data-buffer (url-retrieve url callback cbargs))
    (save-excursion
      (set-buffer data-buffer)
      (set (make-local-variable 'url-registered-auth-schemes)
	   url-registered-auth-schemes)
      (set (make-local-variable 'unity-fetching-url) t)
      (set (make-local-variable 'url-passwd-entry-func) 'unity-default-pass))
    )
  )

(defun unity-default-user ()
  "Return the username, asking the user if we haven't cached it."
  (unity-uglify-string
   (or unity-username
       (setq unity-username
	     (read-string "unity username: "
			  (user-full-name) nil (user-full-name))))))

(defun unity-default-pass (&optional prompt ignored)
  "Return the password, asking the user if we haven't cached it."
  (or unity-password
      (setq unity-password (read-passwd prompt))))

(defun unity-edit-callback ()
  "Once the edit page has been fetched, this does the work of parsing
the form and setting up the unity edit buffer."
  (let ((case-fold-search  t)
        (form-beg        nil)
        (form-end        nil)
        (values          nil)
        (texts           nil)
	(inhibit-read-only t))

    (beginning-of-buffer)
    (unity-zap-invisible) ;; remove http-related inline meta-data

    ;; parse the html form data out of the returned buffer
    (setq
     form-beg (progn (search-forward "<form") (match-beginning 0))
     form-end (progn (search-forward "</form")(match-beginning 0))
     values   (unity-grep-values form-beg form-end)
     texts    (unity-grep-texts  form-beg form-end)
     ebuf     (format "*Unity: %s [%s]*" 
		      (unity-fix-string (cdr (assoc "savepage" values)))
		      (unity-timestamp  (cdr (assoc "ts"       values)))) )    

    ;; this should be unnecessary now url-http-parse-headers is fixed below:
    ;; (kill-buffer (current-buffer))

    ;; create (if need be) the edit buffer, zap any old crap in there, set
    ;; up the buffer hooks and store the unity data in it. Add the widgets.
    (setq ebuf (get-buffer-create ebuf))
    (pop-to-buffer ebuf)
    (widen)
    (delete-region (point-min) (point-max))
    (setq unity-edit-data (list (cons :values values)
                                (cons :texts  texts )) )
    (add-hook 'kill-buffer-hook 'unity-kill-related nil :local)
    (mapcar (lambda (text) (unity-text-section text)) texts)
    ;; we're done. hand over to the user:
    (unity-mode) ))

(defconst unity-response-ok-fmt
  "</table>\\(\\(?:.\\|\n\\)*?\\)<a [^>]*name\\s-*=\\s-*\"%s\"")

(defun unity-display-response (&optional page buffer)
  "If possible, fillet the Unity response and display it in the message area.
Otherwise show the whole response."
  (save-excursion
    (let ((start  (point-min))
	  (re-editing nil)
	  (regex  (format unity-response-ok-fmt page))
	  (regex2 "<body\\(?:.\\|\n\\)+\\(Re-edit: \\(?:.\\|\n\\)*?\\)<form"))
      ;; look for message we understand:
      (cond
       ;; the Ok/accepted message:
       ( (progn (goto-char start) (search-forward-regexp regex  nil :no-error))
	 (message "%s" (unity-strip-tags (match-string 1))) )
       ;; whoops, we collided:
       ( (progn (goto-char start) (search-forward-regexp regex2 nil :no-error))
	 (setq re-editing t)
	 (message
	  "%s" (unity-compact-string (unity-strip-tags (match-string 1))))
	 (unity-edit-callback) )
       ;; arse. something unexpected:
       ( t (display-buffer (current-buffer)) ) )

      ;; if we collided, rename the old buffer instead of killing it:
      (if (bufferp buffer)
	  (if re-editing
	      (let ((cbuf (current-buffer)))
		(set-buffer buffer)
		(rename-buffer
		 (replace-regexp-in-string "\\[.+\\]"
					   "[OLD]" (buffer-name)))
		(set-buffer cbuf))
	    ;;(message "killing unity buffer: %S" buffer)
	    (kill-buffer buffer) )) ))
  ;; this kills the http data buffer, may not be necessary now that
  ;; url-http-parse-headers is fixed below:
  (kill-buffer (current-buffer) ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; unity table helper functions (noninteractive):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun unity-table-seek-start ()
  "Move to the start of the current table."
  (let ((goal nil))
    (save-excursion
      (while (and (= 0 (forward-line -1)) (looking-at "^[ \t]*\\(||\\)"))
	(setq goal (match-beginning 1)) ))
    (if (not goal)
	(save-excursion
	  (beginning-of-line)
	  (if (looking-at "^[ \t]*\\(||\\)")
	      (setq goal (match-beginning 1)) ) ))
    (and goal (goto-char goal)) ))

(defun unity-table-headers ()
  "Return as a list of strings the contents of the header columns of the
current table \(sans markup and leading/trailing whitespace\)."
  (save-excursion
    (and (unity-table-seek-start)
	 (unity-table-row-data  )) ))

(defun unity-table-row-data (&optional cellfun)
  "Process the current table row, returning a list consisting of the contents
of each cell. Actually, this applies CELLFUN to each cell\'s data and returns
the result of that call in the place of the cell\'s data. If CELLFUN is
unspecified or nil, strips unity markup and leading/trailing whitespace from
the cell\'s data. To get the raw data, use a CELLFUN of `identity'."
  (let ( (table-row nil)
	 (cells     nil) )
    (save-excursion
      (beginning-of-line)
      (when (and (looking-at  "^[ \t]*\\(||.+\\)")
		 (setq table-row (match-string 1)))
	(set-text-properties 0 (length table-row) nil table-row)
	(setq table-row (replace-regexp-in-string "\\s-*$" "" table-row)
	      cells     (split-string table-row "||")) ) )
    (setq cellfun 
	  (or cellfun
	      (lambda (C) (unity-trim-whitespace (unity-strip-markup C))) ))
    (mapcar cellfun cells) ))

(defun unity-table-data (&optional cellfun rowfun)
  "Return a list of row contents for the current table, each element of the
list being a list of cell contents for that row. CELLFUN is passed to
`unity-table-row-data' its parameter. ROWFUN is called on each row list
generated by `unity-table-row-data', the actual value returned for each row
is the return value of this list. ROWFUN defaults to `identity'."
  (let ((row nil) (table-data nil))
    (or rowfun (setq rowfun 'identity))
    (save-excursion
      (when (unity-table-seek-start)
	(while (and (not (eobp))
		    (setq row (unity-table-row-data cellfun)))
	  (setq table-data (cons (funcall rowfun row) table-data))
	  (forward-line 1) )))
    (nreverse table-data)))

(defun unity-table-column-data (col &optional cellfun)
  (unity-table-data cellfun (lambda (row) (nth (1- col) row))))

(defun unity-table-column-number (point)
  "Return the table column number at the position POINT. Column 0 is the
non-column before the table actually starts. The partial column at the end
of the row \(the one without a trailing ||\) is counted as a full column."
  (interactive "d")
  (save-excursion
    (beginning-of-line)
    (if (looking-at "^[ \t]*||")
	(let ((column 0))
	  (while (search-forward "||" point :no-error)
	    (setq column (1+ column)))
	  column)) ))

(defun unity-table-seek-column (col-number)
  "Move to the beginning of column COL-NUMBER on this row."
  (let ((goal nil) (end nil) (nth 0))
    (save-excursion
      (end-of-line)
      (setq end (point))
      (beginning-of-line)
      (when (looking-at "^[ \t]*||")
	(while (and (> col-number nth) (search-forward "||" end :no-error))
	  (setq nth (1+ nth)) )
	(setq goal (point)) ))
    (and goal (goto-char goal)) ))

(defun unity-table-count-columns ()
  "Return the number of columns \(including the trailing partial column\)."
  (save-excursion (end-of-line) (unity-table-column-number (point))) )

(defun unity-table-pad-row (n)
  "Pad the current row to at least N columns, inserting placeholder cells.
Returns the number of columns in the row after any padding is done."
  (let ((cols (unity-table-count-columns)) (head nil) (full nil))
    (cond
     ((not  cols)  nil)
     ((>= cols n) cols)
     (t (setq head (unity-table-headers))
	(beginning-of-line)
	(setq full (looking-at ".*||\\s-*$"))
	(end-of-line)
	(if full nil (insert " ||") (setq cols (+ 1 cols)))
	(while (> (- n cols) 0)
	  (insert (format " <%s> ||" (nth (1- cols) head)))
	  (setq cols (+ 1 cols))) cols) )))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; unity interactive functions for the ui:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun unity-diff ()
  "Diff the buffer with its original content."
  (interactive)
  (if (not unity-edit-data) (error "Unity: Not a valid unity-edit buffer"))
  (let ( (page     (cdr (assoc "savepage" (assoc :values unity-edit-data))))
	 (old-data (cdr (assoc "savetext" (assoc :texts  unity-edit-data))))
	 (new-data (cdr (assoc "savetext" (unity-parse-buffer)           )))
	 (caught       nil)
	 (done         nil)
	 (old-filename nil)
	 (new-filename nil)
	 (diff-buffer  nil))
    (while (not done)
      (setq old-filename (make-temp-name (format "/tmp/old:%s" page)))
      (condition-case caught
	  (progn
	    (write-region old-data nil old-filename nil 0 nil :o-excl)
	    (setq done t))
	(error nil)) )
    (setq done nil)
    (while (not done)
      (setq new-filename (make-temp-name (format "/tmp/new:%s" page)))
      (condition-case caught
	  (progn
	    (write-region new-data nil new-filename nil 0 nil :o-excl)
	    (setq done t))
	(error nil)) )
    (require 'diff)
    (diff old-filename new-filename)
    ;(delete-file old-filename)
    ;(delete-file new-filename)
    )
  )

(defun unity-idiff ()
  "Interactively diff your changes to a unity buffer with the original data."
  (interactive)
  (if (not unity-edit-data) (error "Unity: Not a valid unity-edit buffer"))
  (let ( (old-buffer nil)
	 (new-buffer nil)
	 (old-texts  (cdr (assoc :texts unity-edit-data))) )
    ;; create the "old version" buffer and add it to the list of secondary
    ;; buffers related to this one:
    (setq
     new-buffer (current-buffer)
     old-buffer (get-buffer-create
		 (replace-regexp-in-string "\\[.+\\]"
					   "[ORIGINAL]" (buffer-name))))
    (setq unity-twin-buffers (cons old-buffer unity-twin-buffers))

    ;; clear out any old garbage in the old-version buffer:
    (set-buffer old-buffer)
    (let ((inhibit-read-only t))
      (widen)
      (delete-region (point-min) (point-max)))

    ;; insert widgets for the old data:
    (mapcar (lambda (text) (unity-text-section text)) old-texts)

    ;; now shamelessly piggy back on someone else's hard work.
    ;; I mean, re-use code, yes, that's what I mean...
    (require 'ediff)
    (ediff-buffers old-buffer new-buffer) ))

(defun unity-follow ()
  "Edit the unity page pointed at by the wiki link at the current position."
  (interactive)
  (let ( (target (or (unity-target-at-point (point))
		     (read-string  "unity target: "))) )
    (unity-edit target) ))

(defun unity-save ()
  "Save the current buffer's Unity page. Display the response from the
Unity server when done. \(Ideally just the relevant text, but if unity.el
is uncertain of the response, it will barf up the whole response for you
to see\)."
  (interactive)
  (if (not unity-edit-data) (error "Unity: Not a valid unity-edit buffer"))
  (let ((save-text (unity-parse-buffer))
	(save-vals (cdr (assoc :values unity-edit-data)))
        (unity-buf (current-buffer))
	(postdata  nil)
	(page      nil))
    (setq postdata
	   (apply 'concat
		  (mapcar
		   (lambda (X)
		     (apply (lambda (A B) (concat ";" A "=" B))
			    (unity-query-encode (list (car X) (cdr X)))))
		   (append save-text save-vals)) ) )
    (setq postdata (substring postdata 1))
    (setq page (cdr (assoc "savepage" save-vals)))
    (let ((url-request-data   postdata)
	  (url-request-method "POST"  ))
      (unity-fetch unity-base-url
		   'unity-display-response (list page unity-buf))) ))

(defun unity-edit (target)
  "Edit a Unity page. The target need not be in any particular capitalisation:
words separated by spaces or underscores should work equally well.\n
Asynchronously fetches the Unity page in question, then displays a buffer
allowing you to edit the text and graveyard.\n
You may have more than one page open at once.\n
See also: `unity-save'"
  (interactive "sunity target: ")
  (let* ((url-path   (unity-uglify-string            target))
         (url-string (concat unity-base-url "?edit=" url-path))
         (url-vector                                 nil))
    (setq url-vector (url-generic-parse-url url-string))

    ;; get the username if it wasn't specified:
    (and (url-user url-vector)
         (setq unity-username (url-user url-vector))
         (url-set-user url-vector nil))

    ;; get the password if it wasn't specified:
    (and (url-password url-vector)
         (setq unity-password (url-password url-vector))
         (url-set-password url-vector nil))

    ;;(message "%s" url-string)
    (unity-fetch url-vector 'unity-edit-callback nil) ))

(defun unity-electric-maybe-comment ()
  (interactive)
  (insert "<")
  (if unity-electric-comments
      (condition-case nil
	  (save-excursion
	    (if (equal (buffer-substring (- (point) 3) (point)) "<<<")
		(insert (format " -- [%s] >>>"
				(unity-fix-string (unity-default-user)))) ))
	(error nil)) ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; and table ui functions 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun unity-table-add-row ()
  "Add a table row immediately after the current table row, or at the
end of the table if we are on a line immediately following a table."
  (interactive)
  (let ((cols (unity-table-headers)))
    (when cols
      ;; put the point at the beginning of the line after this row, or the 
      ;; beginning of the line after the last row if we are not in a row.
      (beginning-of-line)
      (when (and (looking-at "^[ \t]*||")
		 (progn (end-of-line)
			(= 1 (forward-line  1))) )
	(insert "\n"))
      (insert "|| <" (unity-join "> || <" cols) "> ||\n")
      (forward-line -1) )) )

(defun unity-table-add-column (name)
  "Add a column with a head cell containing NAME and each subsequent
row containing <NAME> \(in case the table is unaligned\) after the
current column."
  (interactive "scolumn-name: ")
  (let ((col (1+ (unity-table-column-number (point))))
	(str (format " <%s> ||" name)))
    (end-of-line)
    (if (< (unity-table-column-number (point)) col)
	(setq col (- col 1)))
    (unity-table-seek-start)
    (while (and (not (eobp)) (unity-table-seek-column col))
      (unity-table-pad-row col)
      (insert str)
      (forward-line 1)) ))

(defun unity-table-del-column ()
  "Delete the current column from the table. If you are before the first
column, the first column will be deleted instead. If you are after the
last, nothing will be removed."
  (interactive)
  (let ((col (unity-table-column-number (point))) (move 0))
    (if (= col 0) (setq col 1))
    (unity-table-seek-start)
    (while (and (= move 0) (unity-table-seek-column col))
      (backward-char 2)
      (if (looking-at "\\(||.+?\\)||")
	  (delete-region (match-beginning 1) (match-end 1)))
      (end-of-line)
      (setq move (forward-line)) ) ))

(defun unity-table-align ()
  "Align the current table, sort of, excluding cells that are too big."
  (interactive)
  (or (unity-table-seek-start) (error "Unity: No table found"))
  (let ((table  (unity-table-data 'unity-trim-whitespace))
	(ncols   nil) ;; (max) number of columns
	(col-len nil) ;; column lengths (space trimmed)
	(col-nzl nil) ;; ditto, excluding zero-length 
	(col-fmt nil) ;; list of format strings
	(fmt-lst nil) ;; temp pointer to same
	(x         0));; 
    (setq ncols (apply 'max (mapcar 'length table)))
    ;; iterate over the columns:
    (while (< x ncols)
      ;; work out the list of column lengths, and the list excluding
      ;; 0 length columns:
      (setq col-len (mapcar (lambda (row) (length (nth x row))) table)
	    col-nzl (apply 'append
			   (mapcar
			    (lambda (l) (if (= l 0) nil (list l))) col-len)))

      ;; work out the maximum, standard deviation and mean of the length
      ;; for this column. We fiddle the mean by excluding 0 length columns.
      (let ( (max (apply 'max col-len))
	     (std (sqrt (unity-sample-variance col-len)))
	     (avg (unity-mean col-nzl))
	     (len nil) )
	;; ideal column length is either maximum or mean + 3 std deviations
	(setq len (min max (+ (* std 3) avg)))
	;;(message "-%S: %d ±%d [%d]" col-len avg std max)
	;; if some columns would be chopped out by this, exclude them and
	;; recalculate the maximum, using this trimmed max as the ideal length:
	(if (> max len)
	  (setq col-nzl
		(apply 'append
		       (mapcar
			(lambda (l) (if (> l len) nil (list l))) col-nzl))
		len (apply 'max col-nzl)))
	;; record the ideal format for this column
	;;(message "+%S: %d ±%f [%d]\n" col-nzl avg std max)
	(setq fmt (format " %%-%ds ||" len)
	      col-fmt (cons fmt col-fmt)) )
      (setq x (1+ x)) )
    ;; whoops, we build these up in reverse order because it's easier.
    (setq col-fmt (nreverse col-fmt))
    ;; we are at the start of the table: kill the old table:
    (beginning-of-line)
    (let* ( (jmp (length table))
	    (beg (point))
	    (end (line-end-position jmp)) )
      (delete-region beg end))
    ;; print out the new one:
    (mapcar
     (lambda (row)
       (insert "||")
       (setq fmt-list col-fmt)
       (mapcar (lambda (cell)
		 (insert (format (car fmt-list) cell))
		 (setq fmt-list (cdr fmt-list))) row) (insert "\n")) table))
  (delete-char -1))

(defun unity-table-whereami ()
  (interactive)
  (let ( (col  (unity-table-column-number (point)))
	 (head (unity-table-headers)) )
    (if (and col (> 0 col) head)
	(message "You are in column #%d [%s]" col (nth (- col 1) head))
      (message "You are in a maze of wiki markup, all alike."))
    )
  )

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; define unity-mode based on text-mode
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defvar unity-mode-map
  (let ((map (make-sparse-keymap)))
    (set-keymap-parent map text-mode-map)
    (define-key map (kbd "C-x C-s")   'unity-save)
    (define-key map (kbd "C-c C-c")   'unity-save)
    (define-key map (kbd "C-c C-f")   'unity-follow)
    (define-key map (kbd "C-c t r")   'unity-table-add-row)
    (define-key map (kbd "C-c t c")   'unity-table-add-column)
    (define-key map (kbd "C-c t k")   'unity-table-add-column)
    (define-key map (kbd "C-c t TAB") 'unity-table-align)
    (define-key map (kbd "C-c t ?")   'unity-table-whereami)
    (define-key map (kbd "C-c d i")   'unity-idiff)
    (define-key map (kbd "C-c d =")   'unity-diff)
    (define-key map "<"               'unity-electric-maybe-comment)
    map))

(defvar unity-mode-keywords
  '( ("^<[^<>]+>" (0 'mode-line t))
     ("\\<[A-Z][a-zA-Z]+\\(?:[A-Z][a-z]+\\)+\\>" . font-lock-keyword-face)
     ("\\(\\[\\)\\([^[ \t].+?\\)\\(\\]\\)"
      (1 font-lock-builtin-face t)
      (2 font-lock-keyword-face t)
      (3 font-lock-builtin-face t))
     ("\\(?:^\\|[^']\\)\\(''\\)\\([^'].*?\\)\\(''\\)\\(?:[^']\\|$\\)"
      (1 font-lock-builtin-face t)
      (2 'italic prepend)
      (3 font-lock-builtin-face t))
     ("\\('''\\)\\(.*?\\)\\('''\\)"
      (1 font-lock-builtin-face t)
      (2 'bold prepend)
      (3 font-lock-builtin-face t))
     ("\\(###\\)\\([^[ \t\n]*\\)"
      (1 font-lock-builtin-face  t)
      (2 font-lock-constant-face t))
     ("||"             (0 font-lock-string-face   t))
     ("\\(||\\)\\s-*$" (1 font-lock-builtin-face  t))
     ("^\\s-*\\(||\\)" (1 font-lock-builtin-face  t))
     ("\\(\\[\\[\\)\\(.+?\\)\\(\\]\\]\\)"
      (1 font-lock-builtin-face       t)
      (2 font-lock-function-name-face t)
      (3 font-lock-builtin-face       t))
     ("\\(?:^\\|[^#]\\)\\(##\\)\\([^[#][^ \t\n]+\\|\\[.+?\\]\\)"
      (1 font-lock-builtin-face  t)
      (2 'underline              append))
     ("\\(?:[^-]\\|^\\)----\\(?:[^-]\\|$\\)" . font-lock-builtin-face)
      ;;("<<<\\(?:.\\|\n\\)+?>>>"
     ;;(0 font-lock-comment-face append))
     )
  "The `unity-mode' setting for `font-lock-defaults.'")

(defvar unity-mode-syntactic-keywords
  '(("{{{"       (0 "|" keep))    ;; generic string fence 1
    ("}}}"       (0 "|" keep))    ;; generic string fence 2
    ("<<<"       (0 "<" keep))    ;; generic comment start
    (">>\\(>\\)" (1 ">" keep))) ) ;; generic comment finish

(define-derived-mode unity-mode text-mode "Unity"
  (setq font-lock-defaults
	`((unity-mode-keywords)
	  nil
	  nil
	  ((?_ . " "))
	  nil
	  (font-lock-syntactic-keywords
	   . ,(copy-sequence unity-mode-syntactic-keywords)) ))
  (setq font-lock-multiline t)
  (font-lock-set-defaults)
  (turn-on-font-lock) )

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;e;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; FIXUP code for bugs in the url libraries:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'cl)
(defun url-http-parse-headers ()
 "Parse and handle HTTP specific headers.
Return t if and only if the current buffer is still active and
should be shown to the user.\n
   <<<<<<<<<<<<<<<<<<<<<<<<<<<<< NOTE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Note that the stock version of this function has a bug with respect to
retrieving pages that require authentication, which results in the
wrong buffer being deleted \(it\'s in the handler for the 401 response
code - `set-buffer'  is missing\).
   <<<<<<<<<<<<<<<<<<<<<<<<<<<<< NOTE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"
  ;; The comments after each status code handled are taken from RFC
  ;; 2616 (HTTP/1.1)
  (declare (special url-http-end-of-headers url-http-response-status
		    url-http-method url-http-data url-http-process
		    url-callback-function url-callback-arguments))
  (if (or (not (boundp 'url-http-end-of-headers))
	  (not url-http-end-of-headers))
      (error "Trying to parse headers in odd buffer: %s" (buffer-name)))
  (goto-char (point-min))
  (url-http-debug "url-http-parse-headers called in (%s)" (buffer-name))
  (url-http-parse-response)
  (mail-narrow-to-head)
  ;;(narrow-to-region (point-min) url-http-end-of-headers)
  (let ((version nil)
	(class nil)
	(success nil))
    (setq class (/ url-http-response-status 100))
    (url-http-debug "Parsed HTTP headers: class=%d status=%d" class url-http-response-status)

    (cond
     ;; Classes of response codes
     ;;
     ;; 5xx = Server Error
     ;; 4xx = Client Error
     ;; 3xx = Redirection
     ;; 2xx = Successful
     ;; 1xx = Informational
     ((= class 1)			; Information messages
      ;; 100 = Continue with request
      ;; 101 = Switching protocols
      ;; 102 = Processing (Added by DAV)
      (url-mark-buffer-as-dead (current-buffer))
      (error "HTTP responses in class 1xx not supported (%d)" url-http-response-status))
     ((= class 2)			; Success
      ;; 200 Ok
      ;; 201 Created
      ;; 202 Accepted
      ;; 203 Non-authoritative information
      ;; 204 No content
      ;; 205 Reset content
      ;; 206 Partial content
      ;; 207 Multi-status (Added by DAV)
      (case url-http-response-status
	((204 205)
	 ;; No new data, just stay at the same document
	 (url-mark-buffer-as-dead (current-buffer)))
	(otherwise
	 ;; Generic success for all others.  Store in the cache, and
	 ;; mark it as successful.
	 (widen)
	 (if (equal url-http-method "GET")
	     (url-store-in-cache (current-buffer)))
	 (setq success t))))
     ((= class 3)			; Redirection
      ;; 300 Multiple choices
      ;; 301 Moved permanently
      ;; 302 Found
      ;; 303 See other
      ;; 304 Not modified
      ;; 305 Use proxy
      ;; 307 Temporary redirect
      (let ((redirect-uri (or (mail-fetch-field "Location")
			      (mail-fetch-field "URI"))))
	(case url-http-response-status
	  (300
	   ;; Quoth the spec (section 10.3.1)
	   ;; -------------------------------
	   ;; The requested resource corresponds to any one of a set of
	   ;; representations, each with its own specific location and
	   ;; agent-driven negotiation information is being provided so
	   ;; that the user can select a preferred representation and
	   ;; redirect its request to that location.
	   ;; [...]
	   ;; If the server has a preferred choice of representation, it
	   ;; SHOULD include the specific URI for that representation in
	   ;; the Location field; user agents MAY use the Location field
	   ;; value for automatic redirection.
	   ;; -------------------------------
	   ;; We do not support agent-driven negotiation, so we just
	   ;; redirect to the preferred URI if one is provided.
	   nil)
	  ((301 302 307)
	   ;; If the 301|302 status code is received in response to a
	   ;; request other than GET or HEAD, the user agent MUST NOT
	   ;; automatically redirect the request unless it can be
	   ;; confirmed by the user, since this might change the
	   ;; conditions under which the request was issued.
	   (if (member url-http-method '("HEAD" "GET"))
	       ;; Automatic redirection is ok
	       nil
	     (if (y-or-n-p (format "Honor redirection for method `%s'? "
				   url-http-method))
		 ;; User said it was ok, it is their neck after all
		 nil
	       (url-mark-buffer-as-dead (current-buffer))
	       (error "Refusing redirection for method `%s'"
		      url-http-method))))
	  (303
	   ;; The response to the request can be found under a different
	   ;; URI and SHOULD be retrieved using a GET method on that
	   ;; resource.
	   (setq url-http-method "GET"
		 url-http-data nil))
	  (304
	   ;; The 304 response MUST NOT contain a message-body.
	   (url-http-debug "Extracting document from cache... (%s)"
			   (url-cache-create-filename (url-view-url t)))
	   (url-http-mark-connection-as-free (url-host url-current-object)
					     (url-port url-current-object)
					     url-http-process)
	   (url-cache-extract (url-cache-create-filename (url-view-url t)))
	   (setq redirect-uri nil
		 success t))
	  (305
	   ;; The requested resource MUST be accessed through the
	   ;; proxy given by the Location field.  The Location field
	   ;; gives the URI of the proxy.  The recipient is expected
	   ;; to repeat this single request via the proxy.  305
	   ;; responses MUST only be generated by origin servers.
	   (error "Redirection thru a proxy server not supported: %s"
		  redirect-uri))
	  (otherwise
	   ;; Treat everything like '300'
	   nil))
	(if (not redirect-uri)
	    ;; Redirection was cancelled for some reason.
	    nil
	  ;; Clean off any whitespace and/or <...> cruft.
	  (if (string-match "\\([^ \t]+\\)[ \t]" redirect-uri)
	      (setq redirect-uri (match-string 1 redirect-uri)))
	  (if (string-match "^<\\(.*\\)>$" redirect-uri)
	      (setq redirect-uri (match-string 1 redirect-uri)))
	  (let ((url-request-method url-http-method)
		(url-request-data url-http-data)
		(url-request-extra-headers url-http-extra-headers))
	    (url-retrieve redirect-uri url-callback-function
			  url-callback-arguments)
	    (url-mark-buffer-as-dead (current-buffer))))))
     ((= class 4)			; Client error
      ;; 400 Bad Request
      ;; 401 Unauthorized
      ;; 402 Payment required
      ;; 403 Forbidden
      ;; 404 Not found
      ;; 405 Method not allowed
      ;; 406 Not acceptable
      ;; 407 Proxy authentication required
      ;; 408 Request time-out
      ;; 409 Conflict
      ;; 410 Gone
      ;; 411 Length required
      ;; 412 Precondition failed
      ;; 413 Request entity too large
      ;; 414 Request-URI too large
      ;; 415 Unsupported media type
      ;; 416 Requested range not satisfiable
      ;; 417 Expectation failed
      ;; 422 Unprocessable Entity (Added by DAV)
      ;; 423 Locked
      ;; 424 Failed Dependency
      (case url-http-response-status
	(401
	 ;; The request requires user authentication.  The response
	 ;; MUST include a WWW-Authenticate header field containing a
	 ;; challenge applicable to the requested resource.  The
	 ;; client MAY repeat the request with a suitable
	 ;; Authorization header field.
	 (url-mark-buffer-as-dead (current-buffer))
	 (set-buffer (url-http-handle-authentication nil)))
	(402
	 ;; This code is reserved for future use
	 (url-mark-buffer-as-dead (current-buffer))
	 (error "Somebody wants you to give them money"))
	(403
	 ;; The server understood the request, but is refusing to
	 ;; fulfill it.  Authorization will not help and the request
	 ;; SHOULD NOT be repeated.
	 (setq success t))
	(404
	 ;; Not found
	 (setq success t))
	(405
	 ;; The method specified in the Request-Line is not allowed
	 ;; for the resource identified by the Request-URI.  The
	 ;; response MUST include an Allow header containing a list of
	 ;; valid methods for the requested resource.
	 (setq success t))
	(406
	 ;; The resource identified by the request is only capable of
	 ;; generating response entities which have content
	 ;; characteristics nota cceptable according to the accept
	 ;; headers sent in the request.
	 (setq success t))
	(407
	 ;; This code is similar to 401 (Unauthorized), but indicates
	 ;; that the client must first authenticate itself with the
	 ;; proxy.  The proxy MUST return a Proxy-Authenticate header
	 ;; field containing a challenge applicable to the proxy for
	 ;; the requested resource.
	 (url-http-handle-authentication t))
	(408
	 ;; The client did not produce a request within the time that
	 ;; the server was prepared to wait.  The client MAY repeat
	 ;; the request without modifications at any later time.
	 (setq success t))
	(409
	 ;; The request could not be completed due to a conflict with
	 ;; the current state of the resource.  This code is only
	 ;; allowed in situations where it is expected that the user
	 ;; mioght be able to resolve the conflict and resubmit the
	 ;; request.  The response body SHOULD include enough
	 ;; information for the user to recognize the source of the
	 ;; conflict.
	 (setq success t))
	(410
	 ;; The requested resource is no longer available at the
	 ;; server and no forwarding address is known.
	 (setq success t))
	(411
	 ;; The server refuses to accept the request without a defined
	 ;; Content-Length.  The client MAY repeat the request if it
	 ;; adds a valid Content-Length header field containing the
	 ;; length of the message-body in the request message.
	 ;;
	 ;; NOTE - this will never happen because
	 ;; `url-http-create-request' automatically calculates the
	 ;; content-length.
	 (setq success t))
	(412
	 ;; The precondition given in one or more of the
	 ;; request-header fields evaluated to false when it was
	 ;; tested on the server.
	 (setq success t))
	((413 414)
	 ;; The server is refusing to process a request because the
	 ;; request entity|URI is larger than the server is willing or
	 ;; able to process.
	 (setq success t))
	(415
	 ;; The server is refusing to service the request because the
	 ;; entity of the request is in a format not supported by the
	 ;; requested resource for the requested method.
	 (setq success t))
	(416
	 ;; A server SHOULD return a response with this status code if
	 ;; a request included a Range request-header field, and none
	 ;; of the range-specifier values in this field overlap the
	 ;; current extent of the selected resource, and the request
	 ;; did not include an If-Range request-header field.
	 (setq success t))
	(417
	 ;; The expectation given in an Expect request-header field
	 ;; could not be met by this server, or, if the server is a
	 ;; proxy, the server has unambiguous evidence that the
	 ;; request could not be met by the next-hop server.
	 (setq success t))
	(otherwise
	 ;; The request could not be understood by the server due to
	 ;; malformed syntax.  The client SHOULD NOT repeat the
	 ;; request without modifications.
	 (setq success t))))
     ((= class 5)
      ;; 500 Internal server error
      ;; 501 Not implemented
      ;; 502 Bad gateway
      ;; 503 Service unavailable
      ;; 504 Gateway time-out
      ;; 505 HTTP version not supported
      ;; 507 Insufficient storage
      (setq success t)
      (case url-http-response-status
	(501
	 ;; The server does not support the functionality required to
	 ;; fulfill the request.
	 nil)
	(502
	 ;; The server, while acting as a gateway or proxy, received
	 ;; an invalid response from the upstream server it accessed
	 ;; in attempting to fulfill the request.
	 nil)
	(503
	 ;; The server is currently unable to handle the request due
	 ;; to a temporary overloading or maintenance of the server.
	 ;; The implication is that this is a temporary condition
	 ;; which will be alleviated after some delay.  If known, the
	 ;; length of the delay MAY be indicated in a Retry-After
	 ;; header.  If no Retry-After is given, the client SHOULD
	 ;; handle the response as it would for a 500 response.
	 nil)
	(504
	 ;; The server, while acting as a gateway or proxy, did not
	 ;; receive a timely response from the upstream server
	 ;; specified by the URI (e.g. HTTP, FTP, LDAP) or some other
	 ;; auxiliary server (e.g. DNS) it needed to access in
	 ;; attempting to complete the request.
	 nil)
	(505
	 ;; The server does not support, or refuses to support, the
	 ;; HTTP protocol version that was used in the request
	 ;; message.
	 nil)
	(507				; DAV
	 ;; The method could not be performed on the resource
	 ;; because the server is unable to store the representation
	 ;; needed to successfully complete the request.  This
	 ;; condition is considered to be temporary.  If the request
	 ;; which received this status code was the result of a user
	 ;; action, the request MUST NOT be repeated until it is
	 ;; requested by a separate user action.
	 nil)))
     (t
      (error "Unknown class of HTTP response code: %d (%d)"
	     class url-http-response-status)))
    (if (not success)
	(url-mark-buffer-as-dead (current-buffer)))
    (url-http-debug "Finished parsing HTTP headers: %S" success)
    (widen)
    success))

(provide 'unity)

;; at http://mathworld.wolfram.com/SampleVarianceComputation.html
;;   wolfram says:
;;
;;   (where µ{x} is the mean of the 1st x items), and N{x} is the xth item,
;;   and VAR( x ) is the variance (sample corrected bias) of the 1st x items:
;;
;; VAR( j ) = (1 - (1 / (j - 1))) VAR( j-1 ) + j ( µ{j} - µ{j-1} )^2
;;
;; now since we also know:
;;
;; µ{j} = ( µ{j-1} (j - 1) + N{j} ) / j
;;
;; we can therefore calculate VAR( N{j} ), from the second item onwards,
;; purely iteratively for each item, having seeded the values for the first
;; item by hand, since they are trivial for one value:
;;
;; Note that although VAR( 1 ) is meaningless, the term falls to 0 so
;; we need not consider it:
;;
;; it should further be noted that this is completely unnecessary, but
;;                                        j
;; it is more interesting than the the ( Σ (x{i} - μ{j})^2 ) / (j - 1)
;;                                        i=1
;; formula.

;; this could be adapted to make a stateful variance generator to which
;; we could feed values as they came in, since we do not require the
;; values (or even the number of values) in advance.

;; (defun unity-sample-variance-b (values)
;;   "Calculate the \(bias corrected\) sample variance for VALUES."
;;   (let ((j   (float 2))                   ;; position in list
;; 	(mu  (float (car values)))        ;; (j-1)th mean
;; 	(muj  nil)                        ;; jth mean
;; 	(V    nil)                        ;; variance so far
;; 	)
;;     (mapc (lambda (N)
;; 	    (setq muj (/ (+ (*  (- j 1) mu) (float N)) j)
;; 		  V   (+ (if V (* (- 1 (/ 1 (- j 1))) V) 0)
;; 			 (* j (expt (- muj mu) 2)))
;; 		  mu  muj
;; 		  j   (1+ j)))
;; 	  (cdr values))
;;     V))