### Creating a New Rocal Application - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_macro/README.md

This command uses the installed `rocal` CLI to scaffold a new Rocal project directory with the specified application name. It sets up the basic project structure, including source files and configuration.

```Bash
$ rocal new -n myapp
```

--------------------------------

### Installing Rocal CLI - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_macro/README.md

This command installs the Rocal command-line interface using Cargo, including the 'cli' feature required for managing Rocal projects. It's a prerequisite for creating, running, building, and publishing Rocal applications.

```Bash
$ cargo install rocal --features="cli"
```

--------------------------------

### Publishing a Rocal Application - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_macro/README.md

This command packages the built Rocal application files into a distributable archive, typically `release.tar.gz`. It prepares the application for deployment to a hosting server.

```Bash
$ rocal publish
```

--------------------------------

### Running a Rocal Application Locally - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_macro/README.md

These commands navigate into the newly created Rocal project directory and then start the development server. The application will typically be accessible via a web browser at the default address (e.g., http://127.0.0.1:3000), though the port can be customized.

```Bash
$ cd myapp
$ rocal run # you can change a port where the app runs with `-p <Port>`. An app runs on 3000 by default
```

--------------------------------

### Building a Rocal Application - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_macro/README.md

This command compiles the Rocal application, typically into a WebAssembly (`.wasm`) module and associated files, preparing it for deployment. It does not start the application but creates the necessary build artifacts.

```Bash
$ rocal build
```

--------------------------------

### Installing Rocal CLI - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_dev_server/README.md

This Bash command installs the Rocal command-line interface (CLI) tool globally using the Rust package manager, Cargo. It requires a working Rust installation and uses the `--features="cli"` flag to ensure the CLI functionality is included during the installation process.

```Bash
$ cargo install rocal --features="cli"
```

--------------------------------

### Creating a Users Table Migration - SQL

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_macro/README.md

This SQL snippet defines the schema for a `users` table, intended to be placed in the `db/migrations` directory. The `migrate!` macro shown previously would execute this script to create or update the database table schema during application startup.

```SQL
create table if not exists users (
  id integer primary key,
  first_name text not null,
  last_name text not null,
  created_at datetime default current_timestamp
);
```

--------------------------------

### Building a Rocal Application - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_dev_server/README.md

This Bash command uses the Rocal CLI to build the application for production or distribution. Unlike `rocal run`, it only performs the build process and does not start a local server.

```Bash
$ rocal build
```

--------------------------------

### Running a Rocal Application - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_dev_server/README.md

These Bash commands first change the current directory into the newly created Rocal project folder (`myapp`). The `rocal run` command then compiles and starts the Rocal application's development server, making it accessible locally, by default on port 3000.

```Bash
$ cd myapp
$ rocal run # you can change a port where the app runs with `-p <Port>`. An app runs on 3000 by default
```

--------------------------------

### Creating a New Rocal Project - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_dev_server/README.md

This Bash command uses the Rocal CLI tool to generate a new Rocal application project. The `-n` flag is used to specify the desired name for the new application directory and project files, which is `myapp` in this example.

```Bash
$ rocal new -n myapp
```

--------------------------------

### Installing and Initializing Rocal Project using Cargo - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_ui/README.md

These Bash commands provide instructions for setting up a Rocal development environment. The first command uses `cargo` to install the Rocal command-line interface (CLI) with the `cli` feature, and the second command uses the installed CLI to create a new project directory named `yourapp`.

```Bash
$ cargo install rocal --features="cli"
$ rocal new -n yourapp
```

--------------------------------

### Executing Database Queries and Commands - Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_macro/README.md

This Rust snippet demonstrates how to interact with the embedded database in Rocal. It shows fetching configuration, executing SQL queries (`query`) to retrieve data into a deserializable struct, and executing SQL commands (`exec`) for data manipulation like insertion. Dependencies include `serde::Deserialize` and Rocal's database interface.

```Rust
use serde::Deserialize;

#[derive(Deserialize)]
struct User {
  id: u32,
  first_name: String,
  last_name: String,
}

let database = crate::CONFIG.get_database().clone();

let result: Result<Vec<User>, JsValue> = database.query("select id, first_name, last_name from users;").await;

database.exec("insert users (first_name, last_name) into ('John', 'Smith');").await;
```

--------------------------------

### Publishing a Rocal Application - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_dev_server/README.md

These Bash commands first change the current directory to the Rocal project root (`myapp`). The `rocal publish` command then builds the application and packages the necessary files into a `release/` directory and a `release.tar.gz` archive, preparing the application for deployment to a hosting server.

```Bash
$ cd myapp
$ rocal publish
```

--------------------------------

### Installing Rocal CLI using Cargo/Bash

Source: https://github.com/rocal-dev/rocal/blob/main/README.md

This Bash command uses Cargo, Rust's package manager, to install the Rocal command-line interface tool. The `--features="cli"` flag ensures the necessary features for the CLI are enabled during installation. This is a prerequisite for creating and managing Rocal projects.

```Bash
$ cargo install rocal --features="cli"
```

--------------------------------

### Defining Rocal Application Routes and MVC Components - Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_macro/README.md

This snippet illustrates the basic structure for defining application routes and associating them with Controller, Action, and View components using Rocal macros like `migrate!`, `route!`, `#[rocal::action]`, and `view!`. It shows how a request is handled from routing to rendering HTML through a template, demonstrating Rocal's MVC pattern.

```Rust
fn run() {
  migrate!("db/migrations");
  
  route! {
    get "/hello-world" => { controller: HelloWorldController, action: index, view: HelloWorldView }
  }
}

// ... in HelloWorldController
impl Controller for HelloWorldController {
  type View = UserView;
}

#[rocal::action]
pub fn index(&self) {
  self.view.index("Hello, World!");
}

// ... in HelloWorldView
pub fn index(&self, message: &str) {
  let template = HelloWorldTemplate::new(self.router.clone());
  template.render(message);
}

// ... in HelloWorldTemplate
fn body(&self, data: Self::Data) -> String {
  view! {
    <h1>{"Welcome to Rocal World!"}</h1>
	
    if data.is_empty() {
      <h2>{"There is no message."}
    } else {	
      <h2>{{ data }}
    }
  }
}
```

--------------------------------

### Building a Rocal Application/Bash

Source: https://github.com/rocal-dev/rocal/blob/main/README.md

This Bash command, executed within the project directory, uses the Rocal CLI to build the Rocal application for deployment without immediately running it. This prepares the necessary WebAssembly and other files.

```Bash
$ rocal build
```

--------------------------------

### Defining a Database Migration Table Creation/SQL

Source: https://github.com/rocal-dev/rocal/blob/main/README.md

This SQL snippet provides an example of a database migration file used by Rocal. It defines the SQL commands to create a `users` table if it doesn't already exist, specifying columns like `id`, `first_name`, `last_name`, and `created_at` with appropriate types and constraints. These files are typically placed in the `db/migrations` directory.

```SQL
create table if not exists users (
  id integer primary key,
  first_name text not null,
  last_name text not null,
  created_at datetime default current_timestamp
);
```

--------------------------------

### Publishing a Rocal Application/Bash

Source: https://github.com/rocal-dev/rocal/blob/main/README.md

These Bash commands, executed from the project root, use the Rocal CLI to prepare the application for publishing. This process generates deployable artifacts (like a `release/` directory and `release.tar.gz`) after potentially compressing them using tools like brotli.

```Bash
$ cd myapp
$ rocal publish
```

--------------------------------

### Installing Rocal CLI Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_cli/README.md

This Bash command installs the Rocal command-line interface (CLI) tool using Rust's cargo package manager. The `--features="cli"` flag ensures that the CLI-specific features are enabled during the installation process, allowing users to interact with Rocal projects from the terminal.

```Bash
$ cargo install rocal --features="cli"
```

--------------------------------

### Creating Rocal Application Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_cli/README.md

This Bash command uses the installed Rocal CLI to create a new Rocal application project. The `-n` flag is used to specify the name of the new application directory and project, in this example, 'myapp'.

```Bash
$ rocal new -n myapp
```

--------------------------------

### Creating a New Rocal Project/Bash

Source: https://github.com/rocal-dev/rocal/blob/main/README.md

This Bash command uses the Rocal CLI to generate a new Rocal project directory. The `-n myapp` argument specifies 'myapp' as the name of the new application directory that will be created.

```Bash
$ rocal new -n myapp
```

--------------------------------

### Installing Rocal CLI - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_core/README.md

Provides the command-line instruction to install the Rocal framework's command-line interface tool globally using `cargo`, which is required for creating and managing Rocal projects. The `--features="cli"` flag enables the CLI functionality.

```bash
$ cargo install rocal --features="cli"
```

--------------------------------

### Running Rocal Application Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_cli/README.md

These Bash commands show how to navigate into a created Rocal project directory and run the application using the Rocal CLI. The `rocal run` command starts the development server, which defaults to port 3000 but can be changed using the `-p` flag.

```Bash
$ cd myapp
$ rocal run # you can change a port where the app runs with `-p <Port>`. An app runs on 3000 by default
```

--------------------------------

### Defining Database Table Schema for Migration - SQL

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_dev_server/README.md

This SQL snippet provides an example of a database migration file content for Rocal. It defines a standard `CREATE TABLE` statement for a `users` table, specifying columns like `id`, `first_name`, `last_name`, and `created_at`, including data types, constraints (primary key, not null), and a default value.

```SQL
create table if not exists users (
  id integer primary key,
  first_name text not null,
  last_name text not null,
  created_at datetime default current_timestamp
);
```

--------------------------------

### Running a Rocal Application - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_core/README.md

Explains the steps to navigate into a Rocal project directory and use the `rocal run` command. This command compiles and starts the development server, making the application accessible locally, typically on port 3000 by default.

```bash
$ cd myapp
$ rocal run # you can change a port where the app runs with `-p <Port>`. An app runs on 3000 by default
```

--------------------------------

### Defining Rocal Application Entry Point, Routes, Controller, View, and Template - Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_dev_server/README.md

This Rust snippet illustrates the core MVC flow in a Rocal application. It shows how to define the application's main `run` function, set up URL routing using the `route!` macro, implement a controller with an action, define a corresponding view, and structure HTML rendering within a template using the `view!` macro, passing data between components.

```Rust
fn run() {
  migrate!("db/migrations");
  
  route! {
    get "/hello-world" => { controller: HelloWorldController, action: index, view: HelloWorldView }
  }
}

// ... in HelloWorldController
impl Controller for HelloWorldController {
  type View = UserView;
}

#[rocal::action]
pub fn index(&self) {
  self.view.index("Hello, World!");
}

// ... in HelloWorldView
pub fn index(&self, message: &str) {
  let template = HelloWorldTemplate::new(self.router.clone());
  template.render(message);
}

// ... in HelloWorldTemplate
fn body(&self, data: Self::Data) -> String {
  view! {
    <h1>{"Welcome to Rocal World!"}</h1>
	
    if data.is_empty() {
      <h2>{"There is no message."}</h2>
    } else {	
      <h2>{{ data }}</h2>
    }
  }
}
```

--------------------------------

### Building Rocal Application Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_cli/README.md

This Bash command uses the Rocal CLI to build the Rocal application project. The `rocal build` command compiles the application code, preparing it for deployment or further processing without starting the development server.

```Bash
$ rocal build
```

--------------------------------

### Installing Rocal CLI via Cargo Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal/README.md

Provides the command to install the Rocal command-line interface tool globally using Cargo, Rust's package manager. Requires Cargo to be installed on the system. The `--features="cli"` flag is necessary to include the CLI functionality.

```Bash
$ cargo install rocal --features="cli"
```

--------------------------------

### Running Rocal Development Server Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal/README.md

Shows the commands to navigate into a Rocal project directory and start the local development server. The `rocal run` command compiles and serves the application, typically on port 3000 by default. The port can be changed using the `-p` option.

```Bash
$ cd myapp
$ rocal run # you can change a port where the app runs with `-p <Port>`. An app runs on 3000 by default
```

--------------------------------

### Running a Rocal Application/Bash

Source: https://github.com/rocal-dev/rocal/blob/main/README.md

These Bash commands navigate into the created project directory ('myapp') and then use the Rocal CLI to build and run the application. By default, the application runs on port 3000, but this can be changed with the `-p` flag.

```Bash
$ cd myapp
$ rocal run # you can change a port where the app runs with `-p <Port>`. An app runs on 3000 by default
```

--------------------------------

### Creating User Table Migration SQL

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_cli/README.md

This SQL script provides an example of a database migration file used by Rocal. Placed in the `db/migrations` directory, it defines the schema for a `users` table, including primary key, text columns, and a default timestamp, used by Rocal's migration system to set up the database.

```SQL
create table if not exists users (
  id integer primary key,
  first_name text not null,
  last_name text not null,
  created_at datetime default current_timestamp
);
```

--------------------------------

### Creating New Rocal Application Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal/README.md

Demonstrates how to use the installed Rocal CLI to generate a new Rocal project directory with a basic application structure. The `-n` flag is used to specify the desired name for the new application directory and project.

```Bash
$ rocal new -n myapp
```

--------------------------------

### Building a Rocal Application - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_core/README.md

Provides the `rocal build` command for compiling a Rocal application without starting the development server. This command is used to generate the necessary WebAssembly and other build artifacts for deployment.

```bash
$ rocal build
```

--------------------------------

### Defining MVC Structure and Routing in Rocal/Rust

Source: https://github.com/rocal-dev/rocal/blob/main/README.md

This Rust snippet demonstrates the core MVC structure in Rocal. It shows how to define application entry points using the `run` function, set up routing with the `route!` macro, implement controllers (`Controller` trait), define actions (`#[rocal::action]`), implement views, and use the `view!` macro for HTML templating. It requires Rocal framework dependencies.

```Rust
fn run() {
  migrate!("db/migrations");
  
  route! {
    get "/hello-world" => { controller: HelloWorldController, action: index, view: HelloWorldView }
  }
}

// ... in HelloWorldController
impl Controller for HelloWorldController {
  type View = UserView;
}

#[rocal::action]
pub fn index(&self) {
  self.view.index("Hello, World!");
}

// ... in HelloWorldView
pub fn index(&self, message: &str) {
  let template = HelloWorldTemplate::new(self.router.clone());
  template.render(message);
}

// ... in HelloWorldTemplate
fn body(&self, data: Self::Data) -> String {
  view! {
    <h1>{"Welcome to Rocal World!"}</h1>
	
    if data.is_empty() {
      <h2>{"There is no message."}</h2>
    } else {	
      <h2>{{ data }}</h2>
    }
  }
}
```

--------------------------------

### Defining Database Migration (Create Users Table) - SQL

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_core/README.md

Presents an example SQL script intended for use as a database migration file within the `db/migrations` directory. This script defines the schema for a `users` table, including columns, primary key, null constraints, and a default timestamp.

```sql
create table if not exists users (
  id integer primary key,
  first_name text not null,
  last_name text not null,
  created_at datetime default current_timestamp
);
```

--------------------------------

### Defining Database Migration Script SQL

Source: https://github.com/rocal-dev/rocal/blob/main/rocal/README.md

Provides an example of a SQL script file used for database migrations in Rocal. This specific script creates a `users` table if it doesn't already exist, defining columns for id, names, and creation timestamp. These files are typically placed in the `db/migrations` directory.

```SQL
create table if not exists users (
  id integer primary key,
  first_name text not null,
  last_name text not null,
  created_at datetime default current_timestamp
);
```

--------------------------------

### Interacting with Embedded SQLite WASM Database Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal/README.md

Illustrates how to query and execute commands against the embedded SQLite WASM database from Rust code within a Rocal application. Shows how to get the database connection and use the asynchronous `query` and `exec` methods. Requires the `serde` crate for deserializing query results.

```Rust
use serde::Deserialize;

#[derive(Deserialize)]
struct User {
  id: u32,
  first_name: String,
  last_name: String,
}

let database = crate::CONFIG.get_database().clone();

let result: Result<Vec<User>, JsValue> = database.query("select id, first_name, last_name from users;").await;

database.exec("insert users (first_name, last_name) into ('John', 'Smith');").await;
```

--------------------------------

### Interacting with Rocal Embedded Database - Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_dev_server/README.md

This Rust snippet shows how to interact with the embedded database (SQLite WASM) in Rocal. It defines a struct (`User`) using `serde::Deserialize` to map query results, obtains a database connection from the configuration, and demonstrates executing select queries (`query`) which return deserialized results and executing DML/DDL commands (`exec`).

```Rust
use serde::Deserialize;

#[derive(Deserialize)]
struct User {
  id: u32,
  first_name: String,
  last_name: String,
}

let database = crate::CONFIG.get_database().clone();

let result: Result<Vec<User>, JsValue> = database.query("select id, first_name, last_name from users;").await;

database.exec("insert users (first_name, last_name) into ('John', 'Smith');").await;
```

--------------------------------

### Performing Database Operations in Rocal/Rust

Source: https://github.com/rocal-dev/rocal/blob/main/README.md

This Rust snippet demonstrates how to interact with the embedded database (SQLite WASM) in a Rocal application. It shows defining a struct for deserialization (`#[derive(Deserialize)]`), obtaining the database instance from the configuration, and executing asynchronous queries (`query`) and non-query commands (`exec`). Requires `serde` and Rocal's database integration.

```Rust
use serde::Deserialize;

#[derive(Deserialize)]
struct User {
  id: u32,
  first_name: String,
  last_name: String,
}

let database = crate::CONFIG.get_database().clone();

let result: Result<Vec<User>, JsValue> = database.query("select id, first_name, last_name from users;").await;

database.exec("insert users (first_name, last_name) into ('John', 'Smith');").await;
```

--------------------------------

### Publishing Rocal Application Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal/README.md

Shows the commands to navigate into a Rocal project directory and publish the application for hosting. The `rocal publish` command prepares release artifacts, including a compressed archive (`release.tar.gz`), suitable for deployment. Requires the `brotli` utility.

```Bash
$ cd myapp
$ rocal publish
```

--------------------------------

### Publishing Rocal Application Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_cli/README.md

This Bash command uses the Rocal CLI to package a Rocal application for publishing. Executing `rocal publish` in the project directory creates release files and an archive, typically located in a `release/` directory and a `release.tar.gz` file.

```Bash
$ cd myapp
$ rocal publish
```

--------------------------------

### Publishing a Rocal Application - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_core/README.md

Shows the command-line instruction `rocal publish` used to prepare a Rocal application for deployment. This command typically packages the built application files into an archive, potentially applying compression like Brotli.

```bash
$ cd myapp
$ rocal publish
```

--------------------------------

### Defining Rocal Application Structure and Routing - Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_core/README.md

Illustrates the basic structure of a Rocal application, including the main `run` function, defining routes using the `route!` macro, implementing the `Controller` trait, defining actions, views, and templates to handle requests and render HTML responses.

```rust
fn run() {
  migrate!("db/migrations");
  
  route! {
    get "/hello-world" => { controller: HelloWorldController, action: index, view: HelloWorldView }
  }
}

// ... in HelloWorldController
impl Controller for HelloWorldController {
  type View = UserView;
}

#[rocal::action]
pub fn index(&self) {
  self.view.index("Hello, World!");
}

// ... in HelloWorldView
pub fn index(&self, message: &str) {
  let template = HelloWorldTemplate::new(self.router.clone());
  template.render(message);
}

// ... in HelloWorldTemplate
fn body(&self, data: Self::Data) -> String {
  view! {
    <h1>{"Welcome to Rocal World!"}</h1>
	
    if data.is_empty() {
      <h2>{"There is no message."}</h2>
    } else {	
      <h2>{{ data }}</h2>
    }
  }
}
```

--------------------------------

### Structuring Rocal Application with MVC Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal/README.md

Illustrates the basic structure of a Rocal application using MVC. Shows how to define routes, implement a controller action with `#[rocal::action]`, define a view, and render an HTML template using the `view!` macro. Requires Rocal framework macros and traits.

```Rust
fn run() {
  migrate!("db/migrations");
  
  route! {
    get "/hello-world" => { controller: HelloWorldController, action: index, view: HelloWorldView }
  }
}

// ... in HelloWorldController
impl Controller for HelloWorldController {
  type View = UserView;
}

#[rocal::action]
pub fn index(&self) {
  self.view.index("Hello, World!");
}

// ... in HelloWorldView
pub fn index(&self, message: &str) {
  let template = HelloWorldTemplate::new(self.router.clone());
  template.render(message);
}

// ... in HelloWorldTemplate
fn body(&self, data: Self::Data) -> String {
  view! {
    <h1>{"Welcome to Rocal World!"}</h1>
	
    if data.is_empty() {
      <h2>{"There is no message."}</h2>
    } else {	
      <h2>{{ data }}</h2>
    }
  }
}
```

--------------------------------

### Creating a New Rocal Project - Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_core/README.md

Shows how to use the Rocal CLI command `rocal new` to generate a new Rocal application project. The `-n` flag is used to specify the desired name for the new application directory.

```bash
$ rocal new -n myapp
```

--------------------------------

### Defining Rocal MVC Structure Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_cli/README.md

This Rust snippet demonstrates the core structure of a Rocal application following the MVC pattern. It shows how to define routes using the `route!` macro, implement the `Controller` trait, define action methods using `#[rocal::action]`, and structure view and template functions for rendering HTML content.

```Rust
fn run() {
  migrate!("db/migrations");
  
  route! {
    get "/hello-world" => { controller: HelloWorldController, action: index, view: HelloWorldView }
  }
}

// ... in HelloWorldController
impl Controller for HelloWorldController {
  type View = UserView;
}

#[rocal::action]
pub fn index(&self) {
  self.view.index("Hello, World!");
}

// ... in HelloWorldView
pub fn index(&self, message: &str) {
  let template = HelloWorldTemplate::new(self.router.clone());
  template.render(message);
}

// ... in HelloWorldTemplate
fn body(&self, data: Self::Data) -> String {
  view! {
    <h1>{"Welcome to Rocal World!"}</h1>
	
    if data.is_empty() {
      <h2>{"There is no message."}</h2>
    } else {	
      <h2>{{ data }}</h2>
    }
  }
}
```

--------------------------------

### Building Rocal Application Bash

Source: https://github.com/rocal-dev/rocal/blob/main/rocal/README.md

Provides the command to build a Rocal application without running it. This command compiles the Rust code to WebAssembly and prepares other necessary assets, typically used before deployment. It requires the Rocal CLI.

```Bash
$ rocal build
```

--------------------------------

### Executing Database Queries Rocal Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_cli/README.md

This Rust snippet demonstrates how to interact with the embedded SQLite WASM database in Rocal. It shows how to define a struct for deserialization using `#[derive(Deserialize)]`, obtain a database connection, execute `SELECT` queries using `.query().await`, and execute non-query statements (`INSERT`, `UPDATE`, `DELETE`) using `.exec().await`.

```Rust
use serde::Deserialize;

#[derive(Deserialize)]
struct User {
  id: u32,
  first_name: String,
  last_name: String,
}

let database = crate::CONFIG.get_database().clone();

let result: Result<Vec<User>, JsValue> = database.query("select id, first_name, last_name from users;").await;

database.exec("insert users (first_name, last_name) into ('John', 'Smith');").await;
```

--------------------------------

### Defining Rocal UI View using Macro - Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_ui/README.md

This Rust snippet illustrates the core syntax of the Rocal UI template engine using the `view!` macro. It demonstrates how to embed variables (`{{ variable }}`), implement `if-else if-else` conditional logic, and use `for` loops to dynamically generate HTML structure and content.

```Rust
view! {
  <div class="container">
    <h1 class="title">{{ title }}</h1>

    if user.id <= 10 {
      <p>{ "You are an early user!" }</p>
      <a href={{ reward_url }}>{ "Click here to get rewards!" }</a>
    } else if user.id <= 20 {
      <p>{ "You are kind of an early user." }</p>
      <a href={{ sort_of_reward_url }}>{ "Check it out for your reward." }</a>
    } else {
      <p>{ "You are a regular user." }</p>
    }

    <hr/>
    
    <ul>
      for article in articles {
        <li><a href={{ article.url }}>{{ article.title }}</a></li>
      }
    </ul>
  </div>
}
```

--------------------------------

### Embedding Views and Expressions in Rocal UI Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_ui/README.md

This Rust snippet demonstrates advanced Rocal UI usage, showing how to define a reusable template fragment or 'partial' (`button`) using `view!` and then embed it within another template using the variable syntax (`{{ &button }}`). It also highlights that variable embedding supports any Rust expression evaluating to `&str`.

```Rust
let button = view! {
  <button type="submit" class="btn btn-primary">
    Submit
  </button>
};

view! {
  <form action={{ &format!("/articles/{}", article.id) }}>
    <input type="text" />
    {{ &button }}
  </form>
}
```

--------------------------------

### Interacting with Embedded Database (SQLite WASM) - Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_core/README.md

Demonstrates how to interact with the embedded SQLite WASM database in Rocal. It shows defining a deserializable struct for query results, obtaining a database connection, and executing both SELECT queries (`query`) and data manipulation commands (`exec`) using asynchronous operations.

```rust
use serde::Deserialize;

#[derive(Deserialize)]
struct User {
  id: u32,
  first_name: String,
  last_name: String,
}

let database = crate::CONFIG.get_database().clone();

let result: Result<Vec<User>, JsValue> = database.query("select id, first_name, last_name from users;").await;

database.exec("insert users (first_name, last_name) into ('John', 'Smith');").await;
```

--------------------------------

### Implementing For Loop in Rocal UI Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_ui/README.md

This Rust snippet illustrates the `for-in` loop syntax available within Rocal UI templates, which follows standard Rust loop semantics. It demonstrates how to iterate over a collection (e.g., `articles`) and generate repetitive HTML elements for each item.

```Rust
for article in articles {
  <li><a href={{ article.url }}>{{ article.title }}</a></li>
}
```

--------------------------------

### Using If-Else Conditionals in Rocal UI Rust

Source: https://github.com/rocal-dev/rocal/blob/main/rocal_ui/README.md

This Rust snippet specifically demonstrates the `if-else if-else` control flow within the Rocal UI template syntax. It shows how to use standard Rust conditional logic directly inside the `view!` macro to render different HTML blocks based on data conditions.

```Rust
if user.id <= 10 {
    <p>{ "You are an early user!" }</p>
    <a href={{ reward_url }}>{ "Click here to get rewards!" }</a>
} else if user.id <= 20 {
   <p>{ "You are kind of an early user." }</p>
   <a href={{ sort_of_reward_url }}>{ "Check it out for your reward." }</a>
} else {
  <p>{ "You are a regular user." }</p>
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.