Rename page feature for newLISP wiki

Posted by tprimke
July 1, 2010

newLISP wiki allows a nice interface to manage wiki, in the Files:

The only thing that is missing is renaming pages. A smart rename should allow user to rename a page, and rename all the references to that page. In this article, I’ll try to document my implementation of this feature.

First of all, I learned about the way newLISP wiki handles HTTP requests. Whole wiki (I think) is placed in index.cgi file. Its starting point is placed after all the auxiliary functions, and then some typical page parts are set (like title and copyright). After this short introducing code (let me name it this way), conditional expressions start. They are responsible for detecting the user’s request and for handling it.

There are many different requests possible, like edit, backup and restore. In my case, I was interested in the files request, since it was the request which displayed a list of all pages, and actions that could be taken on them (like edit or delete). I wanted to add a new action, rename.

So, I wrote a new request, presented below. I added it after all the rest of requests, in hope I won’t brake anything.

  1. ;; request to rename a page
  2. (if (CGI:get "rename")
  3.   (if (CGI:get "continue")
  4.     (letn ( page-old           (CGI:get "rename")
  5.             page-old-filename  (replace " " (dup page-old 1) "_")
  6.             page-new           (CGI:get "new")
  7.             page-new-filename  (replace " " (dup page-new 1) "_") )
  8.       (if (= (length (trim page-new)) 0)
  9.         (let ( body  (append {<p>You haven’t entered any new name for the page } page-old {.</p>}
  10.                              {<p>Try again on <a href="index.cgi?rename=} page-old
  11.                             {">rename page</a>, go to }
  12.                              {<a href="index.cgi?page=} page-old-filename {">} page-old {</a>, or }
  13.                              {get back to <a href="index.cgi">Home</a>.</p>} ) )
  14.           (set ‘body body)
  15.           (set ‘page-name "Rename")
  16.           (CGI:put-page SETUP:template)
  17.           (exit))
  18.         (begin
  19.           (change-refs page-old page-new)
  20.           (rename-file (append "pages/" page-old-filename) (append "pages/" page-new-filename))
  21.           (display-page "Home")
  22.           (exit))))
  23.     (letn ( page-name  (CGI:get "rename")
  24.             bdy  (append {<p>You can rename the page } page-name {.</p>}
  25.                          {<form action="index.cgi" method="post">}
  26.                          {<input type="hidden" name="rename" value="} page-name {" />}
  27.                          {<input type="hidden" name="continue" value="" />}
  28.                          {<p>New page name: <input type="text" name="new" /></p>}
  29.                          {<p>Do you really want to rename the page ?&nbsp;}
  30.                          {<input type="submit" name="submit" class="button" value="Yes" /></p>}
  31.                          {</form>}
  32.                          {<p>You can cancel this action and get back to <a href="index.cgi">Home</a>.</p>}) )
  33.       (set ‘body bdy)
  34.       (set ‘page-name "Rename")
  35.       (CGI:put-page SETUP:template)
  36.       (exit))))

The request handling code can be splitted into two different parts. The first part starts in the line 23 and is responsible for displaying a confirmation message. User can confirm, that he wants to rename the page, or cancel the action. If user confirms, that the page should be renamed, the second part handles the request (it starts in the line 4). It simply changes all the references to the old page to new values and renames the page file (lines 19-22).

The code responsible for changing all the references to the old page name is shown below.

  1. ;; changes all references to the given page-old
  2. ;; to references to the given page-new
  3. (define (change-refs page-old page-new)
  4.   (let ( page-old-filename  (replace "_" (dup page-old 1) ".")
  5.          rexp               (append {\[\[} page-old {\]\]})
  6.          subst              (append {[[} page-new {]]})
  7.          files              (slice (directory "pages/") 2) )
  8.     (dolist (fle files)
  9.       (let ( content  (get-content fle) )
  10.         (if (find rexp content 0)
  11.           (begin
  12.             (replace rexp content subst 512)
  13.             (write-file (append "pages/" fle) content)))))))

Its job is simple: take a look at each file in the “pages” directory, and if you find some reference to the old page, change it to a reference to the new page.

The last thing I changed was adding a proper link to my request in the files table. It was so simple, that I think no code is needed to explain it.

After applying all those changes, I prepared a patch. Now everyone can modify newLISP wiki, and add TOC and rename functionality to this wonderful, small piece of software.

Real-life problems

Did you enjoy this post? Why not leave a comment below and continue the conversation, or subscribe to my feed and get articles like this delivered automatically to your feed reader.

Comments

No comments yet.

Sorry, the comment form is closed at this time.