Capa.scala

package test

import java.lang.String

object Capa {
  import java.io._
  def criaNovo() = {
    val arquivo = new File("capa.html")
    if (arquivo.exists) {
      arquivo.delete;
    }
    arquivo.createNewFile;
    arquivo
  }

  def main(args: Array[String]) {
    val arquivo = criaNovo()

    val out = new FileWriter(arquivo)
    out.write("""<?xml version=" 1.0 " encoding="UTF-8"?>"""+capa.toHtmlString)
    out.close
  }

  import hoops.tc.Html4Strict._

  def capa:hoops.tc.TCBase#Element = {
    html(head(title("TCC: Winter") :: link(rel("stylesheet"), href("capa.css")) :: ENil),
      body(
        div(id("main"))(
          h1("Winter - Um Framework Web Baseado em Funções") ::
          p(cssClass("subtitulo"))("TCC 2010 - Rafael de França Ferreira") ::
          p(cssClass("subtitulo2"))("(orientador: prof. Franscisco Reverbel)") ::
          intro ::
          caixas ::
          andamento ::
          ENil
        )
      )
    )
  }

  lazy val intro = p("""Winter é um framework web experimental que procura explorar o rico sistema de tipos
          da linguagem """::scalaLang::""" para, além de evitar erros, atuar como um
          mecanismo estruturador.""" :: ENil) ::
          p("""Até o momento, a porção mais desenvolvida do framework é a biblioteca de geração de
          html """ ::hoopsSite::""". Esta própria página foi """::gerada::""" usando o Hoops."""::ENil) ::
          ENil

  lazy val caixas =
    div(cssClass("caixas"))(
      div(cssClass("caixa esquerda"))(p(a(href("tcc-parcial.tar.gz"))("Pacote"))),
      div(cssClass("caixa meio"))(p(a(href("monografia.pdf"))("Monografia"))),
      div(cssClass("caixa direita"))(p("Código:") :: ul(
        li(hoopsSite),
        li(winterSite)
      ) :: ENil)
    )

  lazy val andamento = h2("Atividades já realizadas") :: p("""
    Como sugere """ ::RalphJohnson :: """, o melhor caminho para desenvolver um framework é
    a partir de exemplos. O Winter foi desenvolvido seguindo os princípios de Test-Driven-Development,
    com uma série pequenos testes que exercitavam as funcionalidades básicas do framework de ponta a ponta.
    (na monografia discorrerei mais sobre a experiência de TDD em uma linguagem funcional). Assim que os
    mecanismos fundamentais para o tratamento de requests HTTP foram codificados, parti para um teste maior,
    desenvolver uma aplicação simples, mas completa, usando o framework.
    """ :: ENil) :: p("""
    Dada a natureza experimental do projeto, acidentes de percurso eram esperados. No caso, ao desenvolver
    a primeira aplicação, percebi que a tecnologia para a view (produção de html) não estava adequada.
    O Winter usa para este fim a biblioteca """ :: hoopsSite :: """, uma """ :: CombinatorLibrary :: """ que desenvolvi no passado,
    mas que nunca havia sido usada em produção. A opção por uma biblioteca de combinadores tipados para geração
    de HTML, ao invés de um mecanismo de templates tradicional foi feita para aproveitar a composibilidade
    e as garantias estáticas, que coincidem com os objetivos do framework.
    """ :: ENil) :: p("""
    Provou-se necessário re-estruturar a biblioteca Hoops, usando recursos mais avançados do sistema de tipos
    para deixar seu uso mais flexível. A monografia entrará em mais detalhes, mas, em linhas gerais, codificamos
    dentro do sistema de tipos de Scala uma verificação de um predicado binário modelando a relação de "estar-contido" entre
    elementos html, usando o mecanismo de """ :: Implicits :: """ como um motor de backtracking genérico.
    """ :: ENil) ::
    ENil


  lazy val scalaLang = a(href("http://www.scala-lang.org"))("Scala")
  lazy val hoopsSite = a(href("http://bitbucket.org/rafael/hoops"))("Hoops")
  lazy val winterSite = a(href("http://github.com/rafaeldff/winter"))("Winter")
  lazy val gerada = a(href("http://gist.github.com/588969"))("gerada")
  lazy val RalphJohnson = a(href("http://st-www.cs.illinois.edu/users/droberts/evolve.html"))("Ralph Johnson")
  lazy val CombinatorLibrary = a(href("http://en.wikipedia.org/wiki/Combinator_library"))("combinator library")
  lazy val Implicits = a(href("http://www.scala-lang.org/node/114"))("implicits")
}