Lift Web Framework

The Lift Framework is maintained by a volunteer group of Committers. Support is provided based on the version's lifecycle:

• Major Releases (e.g., 3.0.0 to 4.0.0): Contain brand new features and API-incompatible changes.
• Bug Fixes & Performance: Minor improvements are typically shipped for 18 months after a release date.
• Security Fixes: Provided for the previous two minor releases. Once a new major release is out, the last minor release of the previous major version receives security updates for six months after the new major release.

Important: Before opening a GitHub issue, a Pull Request for an older version, or asking for help on the Mailing List, ensure you are using a currently supported version of Lift.

Lift uses a Box[T] abstraction to handle optionality and error states, similar to Scala's Option[T]. This avoids the use of null or nil and provides a type-safe way to represent missing values or failures.

A Box[T] can be:

• Full(value): Contains the actual value of type T.
• Empty: A singleton representing the absence of a value.
• Failure(error): Represents a failure, carrying information about why the value is missing (e.g., an error message or an HTTP response code).

This allows developers to use Scala's 'for' comprehensions to chain operations that might fail without explicit null checks or nested if statements.

for {x <- Some(3); y <- Some(4)} yield x * y

Lift forms are designed to be secure by default, specifically resisting CSRF and BREACH attacks. Instead of using static field names, Lift associates form fields with a callback function. On the client, the field name is a cryptographically secure random value unique to that specific page load. This unique name is tied to the server-side callback you specify, preventing attackers from predicting field names to forge requests.

Note on manual parameter access: You can bypass this security by using S.param("field name") to access submitted fields by a specific name. This returns a Box which is Full if the field was submitted and Empty otherwise. However, using this method exposes your application to CSRF attacks and is strongly discouraged.

Lift uses CSS Selector Transforms to transform HTML blocks by enriching them with data or filtering them based on business rules. A transform is essentially a function with the signature (NodeSeq) => NodeSeq.

A transform consists of three components:

1. The selector: Identifies which elements in the HTML to target.
2. The subnode modification rule: Determines what to do with the matched element (e.g., set its text, change an attribute, or replace it).
3. The transformation function: Provides the actual data or logic used to perform the modification.

Example of a simple transform:

// Replaces the text content of all <a> elements with "Mozilla"
"a *" #> "Mozilla"

When a snippet's data structure becomes more complex than a simple String (e.g., a case class), you can no longer map the list directly to the element content. Instead, you must use CSS selectors to target specific sub-elements within the repeated HTML structure.

If you have a list of ChatMessage objects containing a poster and a body, you can update a snippet by selecting the parent element (e.g., li) and then applying multiple transforms to its children using CSS selectors (e.g., .poster and .body).

def messages = {
    ClearClearable &
    "li" #> messageEntries.map { entry => // <3>
      ".poster *" #> entry.poster &
      ".body *" #> entry.body
    }
}

When choosing between FactoryMaker and Inject, consider the following:

Recommendation: Use Inject if you only need singleton or prototype scopes and do not require session or request-specific overrides.

Lift employs a 'view-first' development model, which reverses the traditional MVC approach. Instead of starting with controllers and data models, you start by building the user interface in pure HTML.

Key characteristics:

• Separation of Concerns: The UI creation process is thoroughly separated from the backend data integration.
• HTML-Centric Workflow: The HTML file is the starting point for development. You define what you want to present to the user in HTML first, and then 'hook up' the backend logic to that existing structure.
• High-Fidelity Mockups: Because Lift works with valid HTML, your initial views act as high-fidelity mockups that can be used for user testing before any backend code is written.

Lift uses the Actor model to handle state and concurrency. A CometActor allows a component to push content to the browser whenever its state changes.

To implement a Comet component:

1. Extend CometActor.
2. Define private state within the class.
3. Implement registerWith to define which server/service the component registers with (following the Observer pattern).
4. Implement lowPriority to handle incoming messages via pattern matching. When a message is received, update the local state and trigger a re-render.
5. Define how the component renders itself by specifying CSS selectors and the replacement HTML/content.

Lift WebKit's Factory extends SimpleInjector and adds advanced scoping capabilities based on the HTTP request or the current container session. This is useful for changing application behavior dynamically based on the user's context.

• Request Scoping: Change behavior for the duration of a single HTTP request.
• Session Scoping: Change behavior for the duration of a user's session.

LiftRules is a Factory, and many of its properties are FactoryMakers that can be scoped.

When using CSS selector transforms to bind a list to elements that already exist in your HTML template (e.g., placeholder <li> tags), Lift will repeat the existing elements for every item in your data list, causing unexpected duplication.

To prevent this, follow these two steps:

1. Tag the placeholder elements in your HTML with the class clearable.
2. Use the ClearClearable transform in your Scala code to remove these tagged elements before applying your data bindings.

You can chain multiple transforms together using the & operator.