On Smalltalk

There can never be enough simple sample apps to help beginners learn Seaside. In that spirit, here's a simple file based Wiki written in pure Seaside (i.e. no Magritte and not overly abstracted to the point you can't figure out what's going on).

It has bookmarkable URLs, uses regex (regex package found on SqueakSource) to make WikiWords into links, keeps line breaks, and accepts raw HTML. Pages are stored on the file system under your image directory based upon the app name.

For a production quality Wiki, use Pier, this one is super simple and only intended for learning. It was written in about two hours (not counting some changes made during the writing of this article) as a single Seaside component.

OK, here we go, broken up into code sections by method category, first declare the class...

WAComponent subclass: #WikiPage
    instanceVariableNames: 'isEditing currentContent currentPage'
    classVariableNames: ''
    poolDictionaries: ''
    category: 'SimpleFileWiki'

Setup the app on the class side...

canBeRoot
    ^ true  

initialize
    self registerAsApplication: #wiki   

Initialize instances of the class...

initialize
    super initialize.
    currentPage := ''.
    isEditing := false

Create some accessing methods we'll need...

currentContent
    ^ currentContent ifNil: [currentContent := '']

currentContent: aString 
    currentContent := aString   

style
    ^ ' textarea {width:90%;height:500px;}' 

Then some fancier accessors that ensure our file system is setup and reads pages from it...

pageDirectory
    ^ (FileDirectory default 
        directoryNamed: self session application name , #Pages) assureExistence 

pageAt: aPage 
    isEditing := (self pageExists: aPage) not.
    isEditing ifTrue: [^ ''].
    ^ FileStream readOnlyFileNamed: (self pageDirectory fullNameFor: aPage)
        do: [:file | file contentsOfEntireFile]

If a page doesn't exist, the Wiki kicks into editing mode to create it. A testing method use by the above...

pageExists: match 
    ^ self pageDirectory fileExists: match  

A couple of actions (our controller methods)...

loadPage: aPage 
    isEditing := false.
    currentPage := aPage.
    self currentContent: (self pageAt: aPage)   

savePage
    self currentContent 
        ifEmpty: 
            [ (self pageExists: currentPage) ifTrue: 
                [ self pageDirectory deleteFileNamed: currentPage.
                self loadPage: #FrontPage ] ]
        ifNotEmpty: 
            [ FileStream 
                forceNewFileNamed: (self pageDirectory fullNameFor: currentPage)
                do: [ :file | file nextPutAll: self currentContent ].
            isEditing := false ]    

cancel
    isEditing := false

Deleting the contents of a page, deletes the page as well.

Now we're ready for rendering. Let's start with page title in the head...

updateRoot: aRoot 
    super updateRoot: aRoot.
    aRoot title: currentPage    

And setting up the url...

updateUrl: aUrl 
    super updateUrl: aUrl.
    aUrl addToPath: currentPage withFirstCharacterDownshifted   

Now that the URL looks valid, lets make it work by parsing new requests, those that don't include the session key (s) or includes an expired session key. Once the session key and the continuation key (k) are present, the URL is no longer necessary and will be ignored. Should this URL be bookmarked and returned to later, after the session has expired, #initialRequest: will be invoked, a new session started, and the correct page served...

initialRequest: aRequest 
    | page url |
    url := aRequest url stringAfter: self application basePath.
    page := (url beginsWith: '/') 
        ifTrue: [ url allButFirst copyAfterLast: $/ ]
        ifFalse: [ url copyAfterLast: $/ ].
    self loadPage: (page ifEmpty: [ 'FrontPage' ] ifNotEmpty: [ page ])

This uses an extension method #stringAfter that I have loaded in all my images, and it relies on another #split that is also in my images. Here they are...

String>>stringAfter: aDelim 
    | list |
    list := self split: aDelim.
    ^ list isEmpty ifTrue: [self] ifFalse: [list last withBlanksTrimmed]

String>>split: aString 
    | index lastIndex |
    index := lastIndex := 1.
    ^ Array streamContents: 
            [:stream | 
            [index <= self size] whileTrue: 
                    [index := self findString: aString startingAt: lastIndex.
                    index = 0 ifTrue: [index := self size + 1].
                    stream nextPut: (self copyFrom: lastIndex to: index - 1).
                    lastIndex := index + aString size]]

Now our main render method which decides which mode the Wiki is in...

renderContentOn: html 
    isEditing 
        ifTrue: [self renderEditorOn: html]
        ifFalse: [self renderViewerOn: html]    

And either edits the Wiki page...

renderEditorOn: html 
    (html heading)
        level1;
        with: ((self pageExists: currentPage) 
                    ifFalse: ['Page ' , currentPage , ' hasn''t been created yet, go for it!']
                    ifTrue: ['Editing ' , currentPage]).
    html form: 
            [html textArea on: #currentContent of: self.
            html break.
            html submitButton on: #savePage of: self.
            html text: ' or '.
            html anchor on: #cancel of: self]

Or renders the viewer which also parses the text for WikiWords and line breaks...

renderViewerOn: html 
    self withLineBreaks: (self currentContent 
                copyWithRegex: '[A-Z][a-z]+([A-Z][a-z]+)+'
                matchesTranslatedUsing: 
                    [:match | 
                    (self pageExists: match) 
                        ifTrue: ['<a href="' , (html urlForAction: [self loadPage: match]) displayString, '">', match , '</a>']
                        ifFalse: [match , '<a href="' , (html urlForAction: [self loadPage: match]) displayString, '">?</a>']])
        on: html.
    html paragraph: 
            [(html anchor)
                callback: [isEditing := true];
                text: 'Edit'.
            html space.
            (html anchor)
                callback: [self loadPage: #FrontPage];
                text: 'FrontPage']  

The editor and viewer could have been separate components, but I'm going for simple here, one class. And finally, the method for breaking lines...

withLineBreaks: aString on: html 
    | stream |
    stream := aString readStream.
    [stream atEnd] whileFalse: 
            [html html: stream nextLine.
            stream atEnd ifFalse: [html break]] 

And there we have it, a simple file based Wiki that covers quite a few things you'd want to do in a web app and should be easily digestible for the Seaside beginner. There are probably bugs, I didn't do a ton of testing and its only intended use is this blog post.

According to the message "WikiPage linesOfCode", that's 90 lines of code total (and that's including the HTML and CSS). Here's a file out of the code for anyone interested. Make sure to manually add the two extension methods to String for this to work.

urlForAction: aBlock
    ^ self context actionUrl withParameter: (self callbacks registerActionCallback: aBlock)