Thread: [Bedouin-devel] Integration of htmlgen

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Hello,

I worked a little bit on htmlgen and wrote a new code generator.

The concrete type for documents is:

type 'a t =
  | Pcdata of string
  | Verbatim of string
  | EmptyElement of string * attrs
  | Element of string * attrs * 'a t list
  | Extension of 'a
and attrs = (string * string) list

This definition allows fast construction of the document tree and is not
specific to a DTD.

The Extension constructor allows to add information that is not part of
the HTML document (an alternative would have been to add an extension
value to each node, but for the applications I have in mind, Extensions
nodes should be rare enough to not justify the overhead).

EmptyElement represents elements without closing tag, such as <hr>,
<br>,...  (and some <p>).

Pcdata nodes may contain special characters that HTML requires to escape,
such as &, <, ...

The generated module (Loose) uses a type:
type ('a,'b) t = 'a Html.t

where 'b is used to enforce DTD constraints.

Constructors look like:

val pcdata_ : string -> ('a,[> `Pcdata]) t

val textarea_ :
  ?id:string ->
  ?class_:string ->
  ?style:string ->
  ?title:string ->
  ?lang:string ->
  ?dir:string ->
  ?onclick:string ->
  ?ondblclick:string ->
  ?onmousedown:string ->
  ?onmouseup:string ->
  ?onmouseover:string ->
  ?onmousemove:string ->
  ?onmouseout:string ->
  ?onkeypress:string ->
  ?onkeydown:string ->
  ?onkeyup:string ->
  ?name:string ->
  ?disabled:string ->
  ?readonly:string ->
  ?tabindex:int ->
  ?accesskey:string ->
  ?onfocus:string ->
  ?onblur:string ->
  ?onselect:string ->
  ?onchange:string ->
  rows:int ->
  cols:int ->
  ('a,[< `Pcdata ]) t ->
  ('a,[> `Textarea]) t

val frameset_ :
  ?id:string ->
  ?class_:string ->
  ?style:string ->
  ?title:string ->
  ?rows:string ->
  ?cols:string ->
  ?onload:string ->
  ?onunload:string ->
  ('a,[< `Frameset | `Frame ]) t list ->
  ('a,[< `Noframes ]) t option ->
  ('a,[> `Frameset]) t

(optional) attributes becomes (optional) labeled arguments; for the
moment, they all have type string except for NUMBER attributes which are
int. The submodes are passed as one or several (for very
few tags, such as frameset above) arguments.

Types are somewhat simpler than those of the previous code generators. The
.mli is no longer produced with ocamlc -i, so it should work with OCaml
3.01 now (its type pretty printer truncated long types).

I also rewrote Gui to work with Loose.t documents (it used to produce HTML
output by a sequence of prints), file gui_dtd.ml in the CVS. It implements
various dynamic type checkings, that can detect if you forget to display a
widget (or if you display it twice, or in the wrong form); these
checks are done by placing Extension nodes in the document tree to keep
track of widgets and containers in the document.

There is a difficulty: the DTD validation trick of htmlgen relies on row
polymorphism with polymorphic variants. As widgets are objects, their html
method must be monomorphic. The good news is that you normally use these
method only once, so we can parametrize widgets class with type variables
constraining the html method type. In some situation, one may want to use
the method twice with different types (if the HTML generation has some
conditionals), and in this situation, an (OCaml) coercion is necessary.

The bad news is that the interface of the module is ugly,
with lots of spurious class parameters (try ocamlc -c -i dtd_gui.ml).
No doubt that life would be even more beautiful with polymorphic methods
in OCaml.

Here is an example demonstrating the new API:

let rec page =
  "page",
  fun app ->
(* Build the page model *)
    let cgi = Application.cgi app in
    let dialog = new dialog app () in
    let form   = new form dialog "form" in
    let set    = new text_field form "set" in
    let submit = new submit form "submit"
                   (fun () ->
                      let n = int_of_string (set # value) in
                      Application.activate app page n) in
    let current = new hidden_field form "current" in
    let increment = new submit form "increment"
                   (fun () ->
                      let n = int_of_string (current # value) in
                      Application.activate app page (n+1)) in
    let reinit = new submit form "reinit"
                   (fun () -> Application.activate app page 0) in

    fun n ->
(* Build the page layout *)
      send cgi (
        dialog # html "A counter" [
          pcdata_ (Printf.sprintf "Counter: %i" n);
          form # html [
            current # html (string_of_int n);
            submit # html "Set to:";
            set # html ();
            br_ ();
            increment # html "++";
            reinit # html "Reinit"
          ]
        ]
      )

(running at:
http://www.eleves.ens.fr:8080/cgi-bin/frisch/gui_dtd.cgi
)

The (send cgi ...) is there because I haven't modified the
Application module yet. Note that it is possible
to build the html out of order (dynamic checks are done at
when the whole HTML document is build):

let f =
  form # html [
    current # html (string_of_int n);
    submit # html "Set to:";
    set # html ();
    br_ ();
    increment # html "++";
    reinit # html "Reinit"
  ]
in
dialog # html "A counter" [
  pcdata_ (Printf.sprintf "Counter: %i" n);
  f
]

What do people think of the HTML production with DTD validation ?
Is it viable ?  Should it be integrated in the core Bedouin
application model ?

Alain

Thread: [Bedouin-devel] Integration of htmlgen

bedouin-devel