miceda

This code shows how to build a simple application with BeepBeep. It demonstrates a simple application flow and the use of filters for authentication.

* UPDATE * The blog demo is not included with the beepbeep source code

Download it here: Blog Demo

It’s completely standalone, so all you need is Erlang and some curiousity.

Setup

- Download the code
- CD into the beebeep_blog_example directory
- run make
- run ./start-server.sh
- point your browser to http://localhost:8000

Since BeepBeep generates the core code and structure for you, the only code I needed to write for this app was:

- src/main_controller.erl – The controller for displaying and creating posts
- src/login_controller.erl – The controller for handling login
- the templates for the app, located in the template directory
- Oh, and the simple blog_db, used to store blog entries in-memory

Go on…give it a try!

BeepBeep is a simple web application framework for Erlang inspired by Rails and Merb. It follows the principle of convention over configuration - meaning if you follow the code structure layout and a few rules when building your app, it’ll require no extra work on you behalf to map Url requests to your Controllers and Views.

BeepBeep is built on Mochiweb and erlyDTL, providing a super fast web server and the ability to define your templates with the Django template language.

Features:

• A Script to generate a new web application (based on mochiweb’s approach)
• Session Server to store your application state
• Before filter on your controllers for things like authentication
• Django templates for the view

Getting Started:

1. download the code here: BeepBeep
2. CD into the beepbeep directory
3. run make
4. generate a new web application by running ./script/new_beep.erl YouAppName “DestinationDirectory

This will create a web app with everything you need. It includes a sample controller (main_controller.erl).

To run the sample:

1. Cd into the new application’s directory you created above and start the server: ./start-server.sh
2. Open a browser and visit “http://localhost:8000″

How it works:

You write a controller similar to how you’d write a “gen_server” based app, but in our case you use the included “gen_controller” behavior. In the controller you define the functions you want to expose to requests. BeepBeep will automatically map Url requests to controller and functions (or actions). For example a request to “/hello/show” would map to the “hello_controller” and invoke the “show” function.

Here’s a controller example:

%% hello_controller.erl
-module(hello_controller).

-export([show/1]).
-export([handle_request/2, before_filter/1]).

-behaviour(gen_controller).
-include("beepbeep.hrl").

show(Params) ->
    gen_controller:call(?MODULE,index,Params).

%% Callback for show
handle_request(show,Params) ->
    {render, "hello/show.html",[{name,"BeepBeep"}],Params}.

%% Callback filter for things like authentication (not using it here)
before_filter(Params) ->
    {ok}.

From “handle_request” we return a tuple that tells the framework what template to use. Templates are located in the template directory. In our example we’ll use the template located in the subdirectory “hello” and the file “show.html”

Here’s an example of the “show.html” template:

 <h2>Hello from {{ name }} </h2>

Which will result in:

<h2>Hello from BeepBeep</h2>

The “name” key set in the controller is passed to the template and expanded using the Django format via erlyDTL.

This BeepBeep approach provides a clean separation of the erlang logic in the controller and the html code in the template.

More to come…