Iliad developer’s guide

Introduction

Iliad is a Smalltalk web application framework. Heavily based on reusable stateful widgets, Iliad lets you build powerful dynamic applications easily. It allows you to trigger Smalltalk code when an user clicks on a link or submits a form instead of bothering you with low level details.
Thanks to its JavaScript layer Iliad automatically uses AJAX requests to update the client state, and it will nicely degrade to normal requests if JavaScript is not enabled, so you don’t have to bother about that either.

Resources

Here is a short list of Iliad related resources:

• the main website of Iliad;
• Iliad mailing-list;
• the issue tracker.

A work in progress

Iliad’s documentation is evolving. We are looking for contributors to help us improve this documentation.

1. Downloading and installing Iliad

Iliad is currently available for GNU Smalltalk, Squeak and Pharo. In this chapter you will find detailed installation instructions for each supported Smalltalk dialect.

1.1 Installing on GNU Smalltalk

gst-package

With GNU Smalltalk 3.2 or newer, gst-package can be used to download and install Iliad.

~$ gst-package --download grease -t ~/.st
~$ gst-package --download iliad -t ~/.st

Git

You can download Iliad by cloning the Git repository.

~$ git clone http://github.com/NicolasPetton/Grease.git
~$ cd Grease
~$ gst-package -t ~/.st ./package.xml

~$ git clone git://github.com/NicolasPetton/iliad-stable.git
~$ cd iliad-stable
~$ ./scripts/make_packages

1.2 Installing on Pharo Smalltalk

Using Metacello

Download ConfigurationOfIliad package from the Metacello repository from squeaksource :

MCHttpRepository
	location: 'http://www.squeaksource.com/MetacelloRepository'
	user: ''
	password: ''

Open a workspace and do-it:

ConfigurationOfIliad load

Manually

Load Swazoo 2.2 and Grease from SqueakSource. Load packages from the SqueakSource repository in the following order:

• Iliad-Core
• Iliad-Swazoo
• Iliad-More-UI
• Iliad-More-Rss
• Iliad-More-Formula
• Iliad-More-Comet
• Iliad-More-Examples
• Iliad-More-Tests

1.3 Loading and starting Iliad

Iliad is webserver agnostic. However, only one server adapter for Swazoo has been written so far. This adapter is available for Pharo Smalltalk and GNU Smalltalk.

1.3.1 GNU Smalltalk

The start script

The git repository of Iliad includes a start script, which will create an image with all required packages loaded and start Iliad with gst-remote.

~$ ./scripts/start -p PORT

gst’s REPL

You can load Iliad packages into a GNU Smalltalk image with the PackageLoader. When using gst’s REPL, you will have to suspend the active process to make Swazoo listen to a given port:

st> PackageLoader fileInPackage: 'Iliad'
st> Iliad.SwazooIliad startOn: 8888
st> processor activeProcess suspend

With gst-remote

You can create a bash script and use it to load the desired packages and start Iliad:

#!/bin/bash

# load packages into a new image named iliad.im
echo "PackageLoader fileInPackage: 'Iliad'. ObjectMemory snapshot: 'iliad.im'" | gst

# start gst-remote with the image
gst-remote --server -I iliad.im &
sleep 2

# start Swazoo on port 8888
gst-remote --eval "Iliad.SwazooIliad startOn: 8888"

1.3.2 Pharo Smalltalk

To start Swazoo with the Iliad adapter, do-it:

SwazooIliad startOn: 8888

1.4 Testing the installation

Open ’http://localhost:8888/browse’ in your browser. You should see the list of loaded Iliad applications.

2. Short tutorial

In this short tutorial we will build our first Iliad widget: a simple counter. Widgets (see section Widgets) are high-level reusable, stateful, graphical objects. We will create the class and a method to build HTML, then add some behavior to increase and decrease the counter.

Our first widget

Widgets are subclasses of ILWidget. Our widget will have a count instance variable, initiliazed to zero.

Iliad.ILWidget subclass: CounterWidget [
    | count |

    initialize [
        super initiliaze.
        count := 0
    ]
]

To build HTML Iliad calls the #contents method of a widget. This method answers a buildable object: almost always a block closure or another widget.

contents [
    ^[:e | e h1: count printString]
]

Action methods

Now we can add action methods to increase and decrease the counter.

increase [
    count := count + 1
]

decrease [
    count := count - 1
]

To allow the user to increase or decrease the counter, we build anchors which will call the action methods (see section Actions), and modify the contents method as follow.

contents [
    ^[:e |
        e h1: self count printString.
        e a 
            action: [self increase];
            text: '++'.
        e a
            action: [self decrease];
            text: '++']
]

To tell Iliad that the state of the counter has changed and that it should be rebuilt, we call its #markDirty method in the action methods.

increase [
    count := count + 1.
    self markDirty
]

decrease [
    count := count - 1.
    self markDirty
]

Using the counter widget in an application

To see our widget in action, we build it in an application. Applications (see section Applications) are similar to widgets except that they dispatch requests in controller methods, similar to the #contents method of widgets. The default controller method is #index.

Iliad.ILApplication subclass: CounterApplication [
    
    CounterApplication class >> path [
        ^'counter'
    ]

    counterWidget [
        ^counterWidget ifNil: [counterWidget := CounterWidget new]
    ]

    index [
        <category: 'controllers'>
        ^self counterWidget
    ]
]

The class side #path method answers the base path of our application.

3. Elements

Elements are low-level stateless objects composed in a tree to build valid (X)HTML. For each element class there is a corresponding HTML tag. This means you will never have to worry about writing valid HTML yourself, but instead use the element API to build HTML in Smalltalk.

#contents methods of widgets (see section Widgets) or controller methods of applications (see section Applications) are called by Iliad to build HTML using elements.

3.1 Composing the element tree

Adding elements

ILHTMLBuilderELement is the root class of the HTML element hierarchy. It has convenience methods for adding other HTML elements, and manipulate HTML attributes. These convenience methods follow HTML tag and attribute names. You can browse them in the adding-convenience protocol. All HTML elements inherit these methods.

The API provides the #add: method for adding a child to an element. Convenience methods use this method to compose the tree of elements.

p [
    <category: 'adding-conveniance'>
    ^self add: ILParagraphElement new
]

The HTML API

Each element in the tree represents a given HTML tag. Each attribute of an element has a corresponding HTML tag attribute. We compose HTML by combining the two kind of methods. As methods are named depending on the HTML tag they represent, building HTML with Iliad looks very similar to actual HTML code.

The following example

e p: 'Hello world'.
e br.
e a
    href: 'http://www.iliadproject.org';
    text: 'Iliad website'.

Will produce the HTML:

<p>Hello world</p>
<br/>
<a href='http://www.iliadproject.org'>Iliad website</a>

Most of the time you won’t have to learn the HTML API if you already know the HTML tag names or attributes you want to write. If you can’t find the name of a convenience method, you can browse the ILHTMLBuilderELement class and its subclasses in Iliad-Core-HTMLElements.

3.2 Elements and buildables

Buildable objects are high-level stateful graphical objects. They use elements to build themselves as HTML. They must implement the #buildOn: method, taking an element as parameter.

A buildable object can be built on an element with the ILElement>>build: method.

Default buildable objects in Iliad includes Block closures and Widgets.

div build: [:e | e text: 'hello world'].
div build: myWidget.

Buildables should never be built using their #contents method or the ILElement>>add: method. Therefore, the following example is not valid.

e add: myWidget contents. "Not valid"
e build: myWidget. "Valid"

Block closures can be used to make building methods simpler by nesting elements.

| div a |
div := e div.
a := div a.
a href: 'http://www.iliadproject.org'.
a img 
    src: 'iliad.png'; 
    alt: 'Iliad logo'.
div h1: 'Iliad rocks!'

Can be written:

e div build: [:div |
    div a build: [:a |
        a href: 'http://www.iliadproject.org'.
        a img
            src: 'iliad.png';
            alt: 'Iliad logo'].
    div h1: 'Iliad rocks!']

And will build the following HTML code:

<div>
    <a href='http://www.iliadproject.org'>
        <img src='iliad.png' alt='Iliad logo'/>
    </a>
    <h1>Iliad rocks!</h1>
</div>

3.3 Actions

Buildables can do more than just build HTML. They can behave, change their state and react to user interactions through Smalltalk code evaluated in actions.

Instead of having to parse URLs and requests, Iliad uses action objects to trigger Smalltalk code when the user interacts with the page, clicks on a link or submits a form. An action is an Iliad object with a Smalltalk block associated to an id, but we will oftenly refer to the block of an action as the action itself.

Actions in anchors

The ILAnchorElement class provides the #action: method to associate an action block to the anchor.

e a
    text: 'Click!';
    action: [Transcript show: 'Anchor clicked.']

Because #action: will add an href attribute with a generated URL, anchors can’t have both an associated action and an href.

e a
    text: 'Click!';
    action: [Transcript show: 'Anchor clicked.'; cr];
    href: 'http://www/smalltalk.org' "This will override the href set by #action:"

The counter widget example in Iliad-More-Examples is a good example of actions in anchors.

contents [
    ^[:e |
        e h1: self count printString.
        e a
            action: [self increase];
            text: '++'.
        e space.
        e a
            action: [self decrease];
            text: '--']
]

Actions in forms

Form elements can also have actions, evaluated when the form is submitted. We can modify the #contents method of the counter example to use a form and buttons instead of anchors.

contents [
    ^[:e |
        e h1: self count printString.
        e form build: [:form |
            form button
                text: '++';
                action: [self increase].
            form button
                text: '--';
                action: [self decrease]]]
]

Some form elements like inputs or textareas take a one argument action block. The argument is the value entered by the user.

e form build: [:form |
    form input action: [:val | self doSomethingWith: val].
    form button text: 'Ok']

3.4 DOM events

Iliad provides a simple API to associate JavaScript code to DOM events (click, focus, etc.) in the accessing attributes-events method protocol. The main method is #on:add: which takes two strings as arguments, the first one for the event, and the last one for the associated JavaScript code. Many shortcut methods exist for specific events, like #onClick: or #onFocus:.

e p 
    text: 'Click';
    onClick: 'alert("clicked!");'.

If an element cannot be associated with a DOM event, an ILAttributeNotUnderstood error will be raised.

Evaluating actions on DOM Events

It is also possible to associate actions to DOM events. Names of methods follow the same convention, but end with do: and take a block as parameter.

e p
    text: 'An action block is evaluated on a click event';
    onClickDo: [Transcript show: 'Clicked!'; cr]

4. Applications

An application is the root of a buildable object tree composing the user interface. Applications are used to dispatch requests to other buildables, typically widgets (see section Widgets), and hold their state. Unlike widgets they don’t have one building method but several controller methods used to dispatch requests to the right buildable object.

Application instances are handled by the framework. Iliad stores one instance of an application class per session, which will persist through requests.

4.1 The base path

Each application class should have an unique base path, a string corresponding to the path of the application. The base path is answered by class method path.

Iliad.ILApplication subclass: MyApplication [
    MyApplication class >> path [
        "Answer the base path of the application"
        ^'my_application'
    ]
]

During a request processing, Iliad will determine to which application the request will be dispatched depending on its base path. If Iliad is running on port 8888, instances of MyApplication will be reached at:

http://localhost:8888/my_application

By default, ILApplication’s path is the empty string. This means the class method path must be overriden, else the application will not be reachable.

The base path of an application is an absolute path and can freely be composed with '/'. We can for example create two application classes with the same first path fragment: '/foo/bar' and '/foo/baz'.

4.2 Controller methods

Controller methods are building methods used to dispatch requests. The application will dispatch the request to the method named after the next fragment of the URL. The default controller method is #index. Concrete applications should always override this method to answer a buildable object.

For example, if the base path of the application is 'foo', the application will try to dispatch a request url '/foo/bar' to the controller method #bar. If there is no method matching this rule, #index will be called.

By default, controller methods must be in the 'controllers' method protocol to be allowed to be called as controller methods (see section Filtering controllers).

A ’hello world’ application

At this point we can write a ’hello world’ application, with a base path and an #index controller.

Iliad.ILApplication subclass: HelloWorldApplication [
    
    HelloWorldApplication class >> path [
        <category: 'accessing'>
        ^'hello_world'
    ]

    index [
        <category: 'controllers'>
        ^[:e | e h1: 'hello world']
    ]
]

After starting Iliad on port 8888, the application can be browsed at http://localhost:8888/hello_world. As expected, the application will dispatch both /hello_world and /hello_world/index to the #index controller.

A multi-counter application

Let’s improve the counter application written in the tutorial (see section Short tutorial) and make it a multi-counter application. The application will build several counter widgets in the #index controller.

Iliad.ILApplication subclass: CounterApplication [
    CounterApplication class >> path [
        <category: 'accessing'>
        ^'counter'
    ]

    initialize [
        <category: ’initialization’>
        super initialize.
        counters := Array
            with: CounterWidget new
            with: CounterWidget new
            with: CounterWidget new
    ]

    index [
        <category: ’controllers’>
        ^[:e |
            counters do: [:each | e build: each]]
    ]
]

To persist through requests, widgets must be stored in instance variables. In this example counters are stored at initialization in a collection.

4.3 Filtering controllers

The use of a method of an application as a controller method is restricted by the selector filter. Each application class has its own selector filter. Each time an application dispatches a request to a controller method, the selector filter block is evaluated against a selector to determine if the corresponding method is allowed to be used as controller or not. The default selector filter allows all methods in the 'controllers' protocol, but you may want to filter selectors differently.

The default selector filter can be overriden in the class side #defaultSelectoreFilter method, or you can plug in a new selector filter with the class side #selectorFilter:. A selector filter block must be a one argument block and answer a boolean.

In the following example, the only selector allowed is #index, all other methods will be forbidden.

MyApplication selectorFilter: [:selector | selector == #index]

4.4 Custom request dispatching

ILApplication provides the #dispatchOverride hook method to handle special cases for dispatching a request. Subclasses of ILApplication should call super first to see if it was already handled.

The behavior of #dispatchOverride is very simple. Before dispatching a request to a controller method, #dispatchOverride is called. If the answer is anything but nil, the application will consider the request as handled and will not dispatch it to a controller method.

See section Using a custom session class, for a simple usage example of this method.

4.5 Updating the page

During the generation of a page for a request processing, the application can update any part of it using the #updatePage: method. This method will be called for each new request excepting AJAX ones. In this method we can for example change the title of the page, update its <head> section, etc.

#updatePage: should not be used to update contents of widgets included in the <body> section, as widgets may not be built yet when Iliad calls #updatePage:.

The argument sent to #updatePage: is an instance of Iliad.ILPage. This class has accessors for both the <head> section and the <body> section of the page, respectively instances of Iliad.ILHeadElement and Iliad.ILBodyElement.

updatePage: aPage [
    <cateogry: 'updating'>
    super updatePage: aPage.
    aPage head title: 'The multi-counter example'.
    aPage head stylesheet href: '/path/to/my/style.css'
]

super should always be called, as Iliad uses Javascript files (see section The Javascript layer) by default to send AJAX requests automatically. See section Serving static files, for more details about how to serve static files with Iliad.

5. Widgets

Iliad web pages are composed of embedded Widgets. Widgets are high-level, reusable graphical objects. Widgets are not only about building HTML, they also hold the state of web applications and will persist through requests. ILWidget is probably the most important class of Iliad, as widgets will compose most of your user interfaces and control flow.

5.1 Maintaining the user interface state

To store the user interface state, applications and widgets must know and store their children. Applications themselves are stored in sessions (see section Managing sessions). Widgets are stored in instance variables in a tree of widgets by their parent, applications or other widgets. During a request processing, after the actions evaluation step, widgets are rebuilt and sent to the client in HTML or JSON (see section Maintaining the client state).

5.2 Maintaining the client state

When updating the client state, refreshing the entire page to update some widgets - therefore rebuilding the entire application with all its children widgets - would be a waste of bandwidth and time. Iliad is designed to automatically build full-blown AJAX applications without hard-coding Javascript inside the HTML page. Because Iliad uses a thin Javascript layer, your content will automatically degrade on clients that don’t have Javascript enabled.

With Javascript enabled web browsers, Iliad automatically uses AJAX to update the client state. The javascript layer (see section The Javascript layer) catches clicks on anchors with actions and form submissions, and send to the server a XmlHTTPRequest. During the request processing, widgets which state has changed are sent back to the browser in JSON. The Javascript layer will then update the page with the new data to keep the client state up-to-date.

The #markDirty method is used to inform Iliad that a widget’s state has changed. It will rebuild it and send it’s new HTML contents in JSON to the client.

5.3 Dependent widgets

5.4 Interacting with other widgets

5.5 Sequencing with ILSequence

5.6 Widget decorators

5.7 Redirecting

5.8 Updating the <head> section of the page

6. Routes and urls

TODO

• The ILRoute object
• Routers
• ILUrlBuilder and the base url

7. Managing sessions

Session objects are automatically instanciated by the framework during the first interaction with an Iliad application. Sessions hold the state of the web application: application instances, actions and states of widgets. They can also be used to keep globally accessible and shared informations among the user interface. A session persists as long as it is active, i.e., as long as the user interacts with the application. After a timeout, if the user is not interacting with the application anymore, the session will expire.

7.1 The session manager

The session manager is the object responsible for managing sessions throughout every Iliad application. The current session manager can be accessed through the class side method ILSessionManager>>current. ILSessionManager implements methods for internal session management. These methods are part of the Iliad core, and are intended to be used while developping, deploying or debugging an Iliad application. Manually removing or invalidate data from sessions is not recommended.

Convenience methods

The session manager can at will remove all sessions it contains:

Iliad.ILSessionManager current removeAllSessions

Expired sessions are automatically removed from the session manager from time to time. However, you can explicitely remove all expired sessions with:

Iliad.ILSessionManager current removeExpiredSessions

Accessing sessions

Sessions can be accessed with the #sessions accessor. Iteration through sessions can be done with #sessionsDo:. Note that widgets and applications should never try to access the current session through the session manager, but instead use their #session accessor.

Accessing the current session from a debugger or an inspector is not always possible since it is only accessible in the context of a request processing. A workaround is to inspect the session object while processing the request by adding the following code inside the #contents method of a widget or inside a controller method of an application:

self session inspect

7.2 Using a custom session class

ILSession is the default session class and can be subclassed to store special informations or handle actions. As an example we will write a session class with very basic login facilities and use it in a simple application.

Iliad.ILSession subclass: MySession [
    | username |

    username [
        ^username
    ]

    username: aString [
        username := aString
    ]
]

We can create an application class that will only be accessible to logged in users:

Iliad.ILApplication subclass: MyApplication [

    MyApplication class >> path [^'my_app']
]

A login form with validation, registration, password recovery, etc. should be built using a custom widget. In a matter of simplicity, here we will just write the form in a building method in the application.

loginContents [
    <category: 'building'>
    ^[:e |
        e form build: [:form |
            form input action: [:val | self login: val].
            form button text: 'Login']]
]

login: aString [
    <category: 'actions'>
    self session username: aString.
    self redirectToCurrentController
]

Testing if the user is logged in or not can happen in a controller method. However, if we want the application to globally accessible to logged in users only, we can use the hook method #dispatchOverride (see section Custom request dispatching).

dispatchOverride [
    <category: 'dispatching'>
    ^self session username 
        ifNil: [self loginContents]
        ifNotNil: [super dispatchOverride]
]

7.3 Handling session expiration

Sessions expire after some time if the user is not interacting with the application. The default timeout is set to 1800 seconds, and can be changed with: ILSession>>expirySeconds:.

When a session expires, Iliad calls its #onExpire method. If you use your own session class, you can override this method to trigger events for session expiration: close database connections, displaying session expiration informations to the user, etc. To illustrate this behavior, we will reuse our session class and logout the user when its session expires.

onExpire [
    <category: 'events'>
    self username: nil.
    super onExpire
]

8. The Javascript layer

9. Serving static files

10. RSS

11. Formula

12. Deploying Iliad applications

TODO

• Configuring apache
• Serving static files
• ILUrlBuilder and rewrite rules

13. Iliad class library reference

Alphabetic list:

Classes documented in this manual are boldfaced.

Object
  Exception
    Error
      Grease.Grease.GRError
        Iliad.ILAttributeError
        Iliad.ILAttributeNotUnderstood
        Iliad.ILDispatchError
        Iliad.ILElementError
        Iliad.ILJsonSyntaxError
    Notification
      Iliad.ILResponseNotification
  Grease.Grease.GRObject
    Iliad.ILObject
      Iliad.ILAction
      Iliad.ILActionRegistry
      Iliad.ILBuildable
        Iliad.ILApplication
        Iliad.ILDecorator
          Iliad.ILAnswerHandler
          Iliad.ILDelegator
            Iliad.ILAppendDelegator
            Iliad.ILPrependDelegator
          Iliad.ILProfiler
        Iliad.ILHTMLPage
        Iliad.ILWidget
          Iliad.ILConfirmationWidget
          Iliad.ILInformationWidget
          Iliad.ILPluggableWidget
          Iliad.ILSequence
      Iliad.ILComposite
        Iliad.ILElement
          Iliad.ILHTMLBuilderElement
            Iliad.ILBodyElement
            Iliad.ILClosingElement
              Iliad.ILAreaElement
              Iliad.ILBreakElement
              Iliad.ILHorizontalRuleElement
              Iliad.ILImageElement
              Iliad.ILMetaElement
              Iliad.ILParameterElement
            Iliad.ILConditionalCommentElement
            Iliad.ILDirectionElement
            Iliad.ILDivElement
            Iliad.ILFieldsetElement
            Iliad.ILFormElement
            Iliad.ILFormElementElement
              Iliad.ILButtonElement
              Iliad.ILCheckboxElement
              Iliad.ILInputElement
              Iliad.ILRadioButtonElement
              Iliad.ILSelectElement
              Iliad.ILTextAreaElement
            Iliad.ILHeadElement
            Iliad.ILHeadingElement
            Iliad.ILHtmlElement
            Iliad.ILLabelElement
            Iliad.ILLegendElement
            Iliad.ILLinkableElement
              Iliad.ILAnchorElement
              Iliad.ILLinkElement
            Iliad.ILListElement
            Iliad.ILListItemElement
            Iliad.ILMapElement
            Iliad.ILObjectElement
            Iliad.ILOptionElement
            Iliad.ILOptionGroupElement
            Iliad.ILParagraphElement
            Iliad.ILRubyTextElement
            Iliad.ILScriptElement
            Iliad.ILSpanElement
            Iliad.ILTableElement
            Iliad.ILTableElementElement
              Iliad.ILTableBodyElement
              Iliad.ILTableCellElement
                Iliad.ILTableDataElement
                Iliad.ILTableHeaderElement
                Iliad.ILTableRowElement
              Iliad.ILTableFootElement
              Iliad.ILTableHeadElement
            Iliad.ILTitleElement
          Iliad.ILRawHtmlElement
          Iliad.ILTextElement
          Iliad.ILXmlElement
      Iliad.ILContext
      Iliad.ILDirectory
        Iliad.ILDiskDirectory
        Iliad.ILMemoryDirectory
      Iliad.ILDispatcher
      Iliad.ILJson
      Iliad.ILJsonObject
      Iliad.ILRequestHandler
        Iliad.ILApplicationHandler
        Iliad.ILErrorHandler
        Iliad.ILFileHandler
        Iliad.ILJsonHandler
        Iliad.ILNotFoundHandler
        Iliad.ILRedirectHandler
      Iliad.ILRoute
      Iliad.ILRouter
      Iliad.ILSession
      Iliad.ILSessionManager
      Iliad.ILStateRegistry
      Iliad.ILUrlBuilder
  Iliad.ILCookie
  Iliad.ILDynamicVariable
    Iliad.ILCurrentBuildable
    Iliad.ILCurrentContext
  Iliad.ILEncoder
  Iliad.ILFileProxy
  Iliad.ILModelProxy
  Iliad.ILRequest
  Iliad.ILResponse
  Iliad.ILUrl
  Iterable
    Collection
      Bag
        Iliad.IdentityBag
      SequenceableCollection
        ArrayedCollection
          ByteArray
            Iliad.ILId

13.1 Iliad.IdentityBag

Defined in namespace Iliad

Superclass: Bag

Category:

13.2 Iliad.ILAction

Defined in namespace Iliad

Superclass: Iliad.ILObject

Category: Iliad-Core-Sessions

13.2.1 Iliad.ILAction: accessing

block

Answer ‘block’.

block: aBlock

Not commented.

key

Answer ‘key’.

key: anId

Not commented.

value

Answer ‘value’.

value: anObject

Not commented.

13.2.2 Iliad.ILAction: converting

respondOn: aResponse

Not commented.

13.2.3 Iliad.ILAction: evaluating

evaluate

Not commented.

13.3 Iliad.ILActionRegistry

Defined in namespace Iliad

Superclass: Iliad.ILObject

Category: Iliad-Core-Sessions

I implement a registry of actions.

13.3.1 Iliad.ILActionRegistry: accessing

actionAt: aKey

Not commented.

actions

Not commented.

13.3.2 Iliad.ILActionRegistry: actions

evaluateActionKey: aString

Not commented.

register: anAction

Not commented.

unregister: anAction

Not commented.

unregisterAllActions

Not commented.

13.4 Iliad.ILAnchorElement

Defined in namespace Iliad

Superclass: Iliad.ILLinkableElement

Category: Iliad-Core-XHTMLElements

13.4.1 Iliad.ILAnchorElement: accessing

action: aBlock

Not commented.

action: aBlock hash: aString

Not commented.

tag

Answer ‘’a”.

13.4.2 Iliad.ILAnchorElement: accessing attributes

tabindex: anInteger

Not commented.

13.4.3 Iliad.ILAnchorElement: accessing attributes-imagemap

circleShape

Not commented.

coords: aString

Not commented.

defaultShape

Not commented.

polyShape

Not commented.

rectShape

Not commented.

shape: aString

Not commented.

13.5 Iliad.ILAnswerHandler

Defined in namespace Iliad

Superclass: Iliad.ILDecorator

Category: Iliad-Core-Buildables

I am a special decorator for Widgets, used to handle widget answers. See #handleAnswer: and ILWidget>>show:onAnswer:

13.5.1 Iliad.ILAnswerHandler: accessing

action

Answer ‘action’.

action: anAction

Not commented.

13.5.2 Iliad.ILAnswerHandler: decorations

handleAnswer: anAnswer

Not commented.

13.6 Iliad.ILAppendDelegator

Defined in namespace Iliad

Superclass: Iliad.ILDelegator

Category: Iliad-Core-Buildables

13.6.1 Iliad.ILAppendDelegator: building

contents

Not commented.

13.7 Iliad.ILApplication

Defined in namespace Iliad

Superclass: Iliad.ILBuildable

Category: Iliad-Core-Buildables

I am the Iliad implementation of an application.

I am is the root object of a buildable object tree. Applications have a set of controllers, methods used to dispatch requests to the corresponding sub-tree of buildable objects (oftenly a composition of stateful widgets).

In concrete subclasses, the class method #path should return the base path (string) for the application.

""""""""""""""""""""""""""" " Applications & UI state " """""""""""""""""""""""""""

You don’t have to bother about instantiating applications, the framework will handle session and application instances. Application instances are stored in sessions. Each session stores one instance of the same application class.

Root widgets should be stored in applications to keep their state across requests.

"""""""""""""""""""""" " Controller methods " """"""""""""""""""""""

Like widgets, I am stateful. Unlike widgets I know how to dispatch a request with #dispatch : the controller method corresponding to the url will be called.

Controller methods must: - answer a buildable object (a block closure or an instance of ILWidget for example). - be in the ’controllers’ method protocol (with the default selector filter)

The default controller method is #index.

"""""""""""""""""" " selectorFilter " """"""""""""""""""

The class inst var <selectorFilter> is used to filter controller methods. By default it allows all methods in the ’controllers’ protocol.

Alternatively, you can override the class method #defaultSelectorFilter to supply your own selectorFilter or plug it in using the class method #selectorFilter:

13.7.1 Iliad.ILApplication class: accessing

absolutePath

Not commented.

path

Base path of the application. Override this method in concrete subclasses. It should return a string

selectorFilter

Not commented.

selectorFilter: aBlock

Not commented.

13.7.2 Iliad.ILApplication class: defaults

defaultSelectorFilter

Override this method to supply your own selectorFilter or plug it in using #selectorFilter:

13.7.3 Iliad.ILApplication: accessing

model

Answer ‘model’.

model: anObject

Not commented.

page

Answer ‘page’.

selectorFilter

Not commented.

widgetFor: aBuildable

Convenience method. This is useful for building anonymous widgets. ex: myWidget := self widgetFor: [:e | e h1: ’Hello world!’]

13.7.4 Iliad.ILApplication: building

buildContents

Call #dispatch. A buildable is expected from #dispatch

13.7.5 Iliad.ILApplication: controllers

index

default view method

13.7.6 Iliad.ILApplication: converting

respondOn: aResponse

Not commented.

13.7.7 Iliad.ILApplication: defaults

defaultPageClass

Answer ‘ILHTMLPage’.

rootElementClass

Answer ‘ILHTMLBuilderElement’.

13.7.8 Iliad.ILApplication: dispatching

allowedSelector: aSelector

Answer true if <aSelector> is ok to call from a URL. Default implementation is to use the pluggable filter block.

dispatch

Dispatch to correct controller method. If dispatchOverride returns something different from nil, consider it handled.

dispatchOn: aMethod

Dispatch to correct method: - If <aMethod> is empty we call #index - If the selector is allowed to be executed then we just call it

dispatchOverride

Handle special urls. Subclass implementors should call super first and see if it was handled.

13.7.9 Iliad.ILApplication: redirecting

respond: aBlock

Abort all other request handling

returnResponse: aResponse

Abort all other request handling

13.7.10 Iliad.ILApplication: updating

updateBaseUrl: anUrl

Answer the receiver.

updateFromRoute: aRoute

Answer the receiver.

updatePage: aPage

Override to add elements to aPage. super should always be called

13.8 Iliad.ILApplicationHandler

Defined in namespace Iliad

Superclass: Iliad.ILRequestHandler

Category: Iliad-Core-RequestHandlers

13.8.1 Iliad.ILApplicationHandler: initialization

initialize

Not commented.

13.8.2 Iliad.ILApplicationHandler: request handling

evaluateActions

Not commented.

handleRequest

Not commented.

13.8.3 Iliad.ILApplicationHandler: responding

produceResponse

Not commented.

13.8.4 Iliad.ILApplicationHandler: testing

isRequestValid

Not commented.

shouldRedirect

Not commented.

shouldRespondInJson

Not commented.

shouldReturnEmptyResponse

Not commented.

13.9 Iliad.ILAreaElement

Defined in namespace Iliad

Superclass: Iliad.ILClosingElement

Category: Iliad-Core-XHTMLElements

13.9.1 Iliad.ILAreaElement: accessing

tag

Answer ‘’area”.

13.9.2 Iliad.ILAreaElement: accessing attributes

accesskey: aCharacter

Not commented.

alt: aString

Not commented.

href: aString

Not commented.

nohref

Not commented.

tabindex: anInteger

Not commented.

13.9.3 Iliad.ILAreaElement: accessing attributes-imagemap

circleShape

Not commented.

coords: aString

Not commented.

defaultShape

Not commented.

polyShape

Not commented.

rectShape

Not commented.

shape: aString

Not commented.

13.10 Iliad.ILAttributeError

Defined in namespace Iliad

Superclass: Grease.Grease.GRError

Category: Iliad-Core-Elements

13.11 Iliad.ILAttributeNotUnderstood

Defined in namespace Iliad

Superclass: Grease.Grease.GRError

Category: Iliad-Core-Elements

13.11.1 Iliad.ILAttributeNotUnderstood class: instance creation

element: anElement attribute: aString

Not commented.

13.11.2 Iliad.ILAttributeNotUnderstood: accessing

attribute

Answer ‘attribute’.

attribute: anObject

Not commented.

element

Answer ‘element’.

element: anElement

Not commented.

13.11.3 Iliad.ILAttributeNotUnderstood: exceptionDescription

defaultAction

Answer the receiver.

isResumable

Answer ‘true’.

13.11.4 Iliad.ILAttributeNotUnderstood: printing

messageText

Not commented.

13.12 Iliad.ILBodyElement

Defined in namespace Iliad

Superclass: Iliad.ILHTMLBuilderElement

Category: Iliad-Core-XHTMLElements

13.12.1 Iliad.ILBodyElement: accessing

tag

Answer ‘’body”.

13.12.2 Iliad.ILBodyElement: addessing attributes-events

onLoad: aString

Not commented.

onUnload: aString

Not commented.

13.13 Iliad.ILBreakElement

Defined in namespace Iliad

Superclass: Iliad.ILClosingElement

Category: Iliad-Core-XHTMLElements

13.13.1 Iliad.ILBreakElement: accessing

tag

Answer ‘’br”.

13.13.2 Iliad.ILBreakElement: accessing attributes-events

onEvent: event add: aString

Not commented.

13.14 Iliad.ILBuildable

Defined in namespace Iliad

Superclass: Iliad.ILObject

Category: Iliad-Core-Buildables

I am an abstract buildable object. My subclasses must override #build method, which should return an instance of a subclass of Iliad.ILElement.

13.14.1 Iliad.ILBuildable: accessing

children

Not commented.

router

Not commented.

13.14.2 Iliad.ILBuildable: accessing attributes

attributeAt: aSymbol

Not commented.

attributeAt: aSymbol ifAbsentPut: aBlock

Not commented.

attributeAt: aSymbol put: anObject

Not commented.

attributes

Not commented.

13.14.3 Iliad.ILBuildable: actions

send: aSymbol

Not commented.

send: aSymbol to: anObject

Not commented.

send: aSymbol to: anObject arguments: anArray

Not commented.

13.14.4 Iliad.ILBuildable: building

build

Not commented.

buildContents

Override this method in subclasses. It must answer an Element

buildOn: anElement

Not commented.

registerChild: aBuildable

Not commented.

13.14.5 Iliad.ILBuildable: converting

respondOn: aResponse

Not commented.

13.14.6 Iliad.ILBuildable: printing

printHtmlString

Not commented.

13.14.7 Iliad.ILBuildable: redirecting

redirectTo: anUrlString

Abort all other request handling. Redirect to anUrlString

redirectToApplication: aClass

Abort all other request handling. Redirect to the index method of <aClass>

redirectToApplication: aClass controller: aString

Abort all other request handling. Redirect to the controller named <aString> of <aClass>

redirectToCurrentController

Abort all other request handling. Redirect to the current controller method

redirectToIndex

Abort all other request handling. Redirect to the index method of this class

redirectToLocal: aString

Abort all other request handling. Make a redirection to another controller method in this application

13.15 Iliad.ILButtonElement

Defined in namespace Iliad

Superclass: Iliad.ILFormElementElement

Category: Iliad-Core-XHTMLElements

13.15.1 Iliad.ILButtonElement: accessing

tag

Answer ‘’button”.

13.15.2 Iliad.ILButtonElement: accessing attributes

beButton

Not commented.

beReset

Not commented.

beSubmit

Not commented.

type: aString

Not commented.

value: aString

Not commented.

13.15.3 Iliad.ILButtonElement: printing

beforePrintHtml

Not commented.

13.16 Iliad.ILCheckboxElement

Defined in namespace Iliad

Superclass: Iliad.ILFormElementElement

Category: Iliad-Core-XHTMLElements

13.16.1 Iliad.ILCheckboxElement: accessing

tag

Answer ‘’input”.

13.16.2 Iliad.ILCheckboxElement: accessing attributes

action: aBlock

Not commented.

beChecked

Not commented.

checked: aBoolean

Not commented.

13.16.3 Iliad.ILCheckboxElement: printing

addHiddenInput

Not commented.

beforePrintHtml

Not commented.

13.17 Iliad.ILClosingElement

Defined in namespace Iliad

Superclass: Iliad.ILHTMLBuilderElement

Category: Iliad-Core-XHTMLElements

13.17.1 Iliad.ILClosingElement: printing

printHtmlOn: aStream

Not commented.

13.18 Iliad.ILComposite

Defined in namespace Iliad

Superclass: Iliad.ILObject

Category: Iliad-Core-Utilities

13.18.1 Iliad.ILComposite: accessing

children

Not commented.

next

Answer ‘next’.

next: aComposite

Not commented.

13.18.2 Iliad.ILComposite: adding

add: aComposite

Not commented.

13.18.3 Iliad.ILComposite: comparing

= anObject

Not commented.

hash

Not commented.

13.18.4 Iliad.ILComposite: enumerating

allChildrenDo: aBlock

Not commented.

childrenDo: aBlock

Not commented.

13.19 Iliad.ILConditionalCommentElement

Defined in namespace Iliad

Superclass: Iliad.ILHTMLBuilderElement

Category: Iliad-Core-XHTMLElements

13.19.1 Iliad.ILConditionalCommentElement: accessing

conditions

Not commented.

13.19.2 Iliad.ILConditionalCommentElement: accessing attributes-events

onEvent: event add: aString

Not commented.

13.19.3 Iliad.ILConditionalCommentElement: conditions

gt

Greater than

ie

Not commented.

ie5

Not commented.

ie50

Not commented.

ie55

Not commented.

ie6

Not commented.

ie7

Not commented.

ie8

Not commented.

lt

Less than

not

Not

13.19.4 Iliad.ILConditionalCommentElement: printing

printCloseTagOn: aStream

Not commented.

printOpenTagOn: aStream

Not commented.

13.20 Iliad.ILConfirmationWidget

Defined in namespace Iliad

Superclass: Iliad.ILWidget

Category: Iliad-Core-Buildables

13.20.1 Iliad.ILConfirmationWidget: accessing

confirmationString

Answer ‘confirmationString’.

confirmationString: aString

Not commented.

13.20.2 Iliad.ILConfirmationWidget: building

contents

Not commented.

13.21 Iliad.ILContext

Defined in namespace Iliad

Superclass: Iliad.ILObject

Category: Iliad-Core-Sessions

I store current request context objects:

- the router - the session - the request itself

I can be accessed through ILObject>>context

13.21.1 Iliad.ILContext: accessing

application

Not commented.

attributes

Not commented.

baseUrl

Not commented.

builtWidgets

Not commented.

previousStateRegistry

Not commented.

request

Answer ‘request’.

request: aRequest

Not commented.

router

Not commented.

session

Answer ‘session’.

session: aSession

Not commented.

stateRegistry

Not commented.

urlBuilder

Not commented.

13.21.2 Iliad.ILContext: accessing-attributes

attributeAt: aKey

Not commented.

attributeAt: aKey put: anObject

Not commented.

13.21.3 Iliad.ILContext: adding

addBuiltWidget: aWidget

Not commented.

13.22 Iliad.ILCookie

Defined in namespace Iliad

Superclass: Object

Category: Iliad-Core-lib-HTTP

From Seaside 2.8

I represent a cookie, a piece of information that is stored on the client and read and writable by the server. I am basically a key/value pair of strings. You can never trust information in a cookie, the client is free to edit it. I model only a part of the full cookie specification.

For more information see RFC2965 (http://tools.ietf.org/html/rfc2965)

13.22.1 Iliad.ILCookie class: instance creation

key: keyString value: valueString

Not commented.

13.22.2 Iliad.ILCookie: accessing

expiry

Answer ‘expiry’.

expiry: anInteger

Not commented.

key

Answer ‘key’.

key: aString

Not commented.

path

Not commented.

path: aString

Not commented.

value

Answer ‘value’.

value: aString

Not commented.

13.22.3 Iliad.ILCookie: api

expireIn: aDuration

Not commented.

valueWithExpiry

Not commented.

13.22.4 Iliad.ILCookie: comparing

= other

Not commented.

hash

Not commented.

13.22.5 Iliad.ILCookie: writing

writeOn: aStream

Not commented.

13.23 Iliad.ILCurrentBuildable

Defined in namespace Iliad

Superclass: Iliad.ILDynamicVariable

Category: Iliad-Core-Buildables

13.24 Iliad.ILCurrentContext

Defined in namespace Iliad

Superclass: Iliad.ILDynamicVariable

Category: Iliad-Core-Sessions

13.25 Iliad.ILDecorator

Defined in namespace Iliad

Superclass: Iliad.ILBuildable

Category: Iliad-Core-Buildables

I am a decorator for Widgets. I can be added to a widget by calling #decorateWith: from a widget. Subclasses can be used to modify the building process of a widget, or change its behavior

13.25.1 Iliad.ILDecorator class: instance creation

decoratee: aDecoratee

Not commented.