21Changelog

3.5.1

Bugfix: Remoção da dependência do Hibernate quando usando GSon como implementação de serialização/deserialização
Bugfix: Correção do linkTo com métodos que recebem argumentos
Possibilidade de registrar (e receber) mais de um componente do mesmo tipo no Guice usando o @Named
Anotações do XStream são processadas automaticamente na serialização e deserialização
Suporte ao BeanValidations 1.1
Melhorias nas validações do BeanValidations em parâmetros dos métodos do controller
Bugfix: Corrigindo registro dos pacotes de serialização e deserialização usando GSon
Serializações agora suportam .excludeAll(), assim você consegue escolher exatamente quais campos quer serializar:
```
    result.use(json()).from(usuario).excludeAll().include("nome", "email").serialize();
        
```
Melhorias no MyDVDs

3.5.0

Bean Validation: Se você usa o Hibernate Validator 3, o suporte foi removido. Atualize para o hiberante validator 4 e adicione o jar da validations api no classpath.

Suporte inicial a validação de métodos (Bean Validation 1.1):

    public void metodo(@NotNull String param) {..} // valida se param != null

Migração do processo de build para maven.
Adicionado novos converters localizados e joda-time (por jlemes).
Remoção de objetos deprecated e não usados.
Removido CGLIB em favor ao Javassist Proxifier.
Google Guice agora é o container padrão. Se você usava alguma classe interna do Spring e Pico ou deseja usar outro container, basta alterar seu pom para incluir as dependências.
Inclusão de suporte a java.util.Set para o IOGI.
Atualização das libs externas.
Suporte ao verbo OPTIONS (por douglasrodrigo) e PATCH (por nykolaslima).
Os testes unitários foram migrados do jmock para mockito. Aumento da cobertura de testes.
Adicionado suporte a serialização com GSON (por renanreismartins).
Alterada a forma como o Exception Handler reporta a exception (por vulpios).
Alterada a assinatura das classes de upload para reportar o tamanho do arquivo (por ljtfreitas).
O suporte ao Hibernate e JPA foram migrados para projetos externos: http://github.com/caelum/vraptor-hibernate e http://github.com/caelum/vraptor-jpa. Caso você use estes projetos deverão ser incluídas manualmente as dependências.
Criado plugin para suporte ao Hibernate 4: http://github.com/garcia-jj/vraptor-plugin-hibernate4.
Os subprojetos vraptor-vraptor2, vraptor-scala, vraptor-flex foram movidos para seus próprios repositórios. Caso você use estes projetos deverão ser incluídas manualmente as dependências.
Melhoria da anotação @Load, onde agora não é mais necessário que o @Id possua o nome fixo ID: basta anotar com @Id o campo da chave primaria.
Validação de beans com suporte a grupos e validação por propriedades (por nykolaslima).
Bugfix para acesso a arquivos estáticos sem o querystring e jsessionid (por nykolaslima).
Bugfix na chamada do método servletContext.getClassLoader (por nykolaslima)
Bugfix para linkto quando o método possui sobrecarga e métodos bridge (por nykolaslima).
Melhorias na validação do upload (por marceloemanoel).
Melhorias na documentação (por bbviana, awvalenti e igordeoliveirasa).

Release Notes

Substitua as chamadas a CglibProxifier para JavassistProxifier
Substitua as chamadas a HibernateMockValidator por MockValidator
Se você usa o pacote br.com.caelum.vraptor.util.hibernate, adicione as seguintes linhas ao pom.xml (se você usa maven)
```
    <dependency>
        <groupId>br.com.caelum.vraptor</groupId>
        <artifactId>vraptor-hibernate</artifactId>
        <version>1.0.0</version>
        <scope>compile</scope>
    </dependency>
  
```
ou adicione o jar no classpath: http://repo1.maven.org/maven2/br/com/caelum/vraptor/vraptor-hibernate/1.0.0/vraptor-hibernate-1.0.0.jar

Se você usa o pacote br.com.caelum.vraptor.util.jpa, adicione as seguintes linhas ao pom.xml (se você usa maven)

    <dependency>
        <groupId>br.com.caelum.vraptor</groupId>
        <artifactId>vraptor-jpa</artifactId>
        <version>1.0.0</version>
        <scope>compile</scope>
    </dependency>

ou adicione o jar no classpath: http://repo1.maven.org/maven2/br/com/caelum/vraptor/vraptor-jpa/1.0.0/vraptor-jpa-1.0.0.jar

3.4.1

PicoProvider agora também seta atributos do request e da session com os nomes dos componentes, da mesma forma que o Guice e o Spring
SpringProvider agora emula o comportamento do ContextLoaderListener, melhorando a integração com os componentes do Spring sem precisar registrar o listener no web.xml
melhor serialização com o XStream, suportando mais casos
correção do plugin do GAE
Locale based converters para tipos primitivos (by Rafael Dipold)
Mudança de padrão IOGI como instanciador de objetos padrão, ao invés do OGNL
suporte a @Consumes("application/x-www-form-urlencoded") (by Celso Dantas)
todas as dependências declaradas no pom.xml agora estão no maven

suporte a @HeaderParam nos métodos do controller:

public void metodo(@HeaderParam("X-meu-param") String param) {..}

suporte a upload de vários arquivos, com nomes file[] (by dgouvea)
bugfix xstream no GAE
atualizando Pico container de 2.8 para 2.13.6 (by Bruno Fuster)
corrigindo scanning de classes nas diversas versões do JBoss (by garcia-jj)
GuiceProvider agora dá preferência ao construtor anotado com @Inject (by cairesvs)
bugfix xstream não é mais opcional
bugfix ordenando parâmetros da requisição, assim é possível usar o converter antes de setar os parâmetros (by Celso Dantas)
bugfix ExtJSView gerando json sem referências (by Éverton Trindade)
bugfix registro de stereotype handlers customizados com o Guice
bugfix chamada de defaultView() dentro de forwards agora vai para a view correta
I18n das mensagens de validação agora são feitas no último momento possível, assim é possível setar o locale na jsp
Possibilidade de sobrescrever o StaticContentHandler.

3.4.0

novo status accepted (result.use(status()).accepted()) - by Vinicius Oliveira
bugfix - race condition na ordenação de interceptors
mock para o bean validations - by @seufagner
bugfix - suportando converter para collections no XStream*Serialization
mudando prioridades padrão das anotações de método (@Get, @Post, etc) para Path.DEFAULT
atualizando jars das dependências do VRaptor - by @wbotelhos
suporte a javassist para gerar os proxies - by garcia-jj

quebra de compatibilidade interna - refatoração da parte de proxies - by garcia-jj. Para todos que usavam diretamente o ObjenesisProxifier ou o DefaultProxifier, o novo jeito é:

new ObjenesisProxifier() ==> new CglibProxifier(new ObjenesisInstanceCreator());
new DefaultProxifier() ==> new CglibProxifier(new ReflectionInstanceCreator());

evitando o wrapping de runtime exceptions nos forwardings
bugfix - upload no GAE, quando usando o Pico

suportando popular parâmetros de objetos conversíveis:

bola = amarela  ==> convertido pelo BolaConverter
bola.tamanho = 23 ==> continuando a popular

suportando popular parâmetros usando atributos de request:

request.setAttribute("bola", new Bola()); //num interceptor, por exemplo

//...

public void logica(Bola bola) { //injetado com o atributo do request!
//...
}

suportando popular parâmetros usando injeção de dependências (somente interfaces):

public void logica(Parametro parametro, Validator validator) {
    //parametro populado com parametros do request
    //validator vindo com injeção de dependências
}

plugin - @Load nos parâmetros das lógicas (....util.hibernate.extra e ....util.jpa.extra)

@Path("/entidade/{entidade.id}") //o id precisa estar preenchido no request
public void minhaLogica(@Load Entidade entidade) {
    //entidade já vem carregada do banco, pelo id, e se não existir retorna 404 automaticamente
    //isso desabilita população da entidade por outros parâmetros do request
}

bugfix - serialização de classes com tipos genéricos - by @wbotelhos
guice - suportando receber List como dependência
plugin - vraptor-flex-plugin melhorado, suportando invocação de lógicas, e injeção de dependências - by @davidpaniz
test - MockSerializationResult, para poder fazer asserções nos objetos serializados. - by Vinicius oliveira
plugin - vraptor-scala-plugin melhorado (usando acessores de propriedades do scala, e ignorando métodos com $). Blank project scala usando sbt. Scala plugin feito em scala agora ;)
melhor suporte ao flash scope automático.
bugfix - corrigido scan de classes no JBoss - by garcia-jj
internal - suporte ao OGNL refatorado para melhorar a estensibilidade. - pair @qmx
bugfix - regexes nos @Path - by Anderson Parra
guice na versão estável (3.0)
Hibernate Validator deprecado (preferência para usar Bean Validations)
bugfix - result.include(null) gerava NullPointerException
bugfix - conversão de listas - by Narciso Benigno
melhores docs do plugin pro GAE - by Roberto Nogueira
serialização de Links em JSON - by A.C de Souza

lazy 18n para validações:

validator.checking(new Validations() { {
    that(a == b, i18n("category"), "message.key", "params");
    // tanto category quanto message.key serão i18n na hora de mostrar a mensagem,
    // usando o resource bundle padrão (do Localization)
}});

deixando a ordenação dos serializations estensível (no result.use(representation())) - by A.C de Souza
Registro do converters do XStream automático. Basta anotar com @Component. - by Rafael Viana
Refatoração dos XStream (de)serializers para usar um XStreamBuilder centralizado e estensível - by Rafael Viana quebra compatibilidade de quem sobrescreveu algum Serializer/Deserializer. Testem!
bugfix - validator.onErrorSendBadRequest não estava setando status 400 - by @wbotelhos

linkTo para os jsps:

@Resource
public class ProdutoController {
    @Path("/produtos/{id}")
    public void carrega(Long id) {..}
}

jsp:

${linkTo[ProdutoController].carrega[2]} ==> /produtos/2

3.3.1

bugfix - corrigido o scannotation como obrigatório no maven
bugfix - corrigido ConcurrentModificationException na ordenação dos interceptors
atualizada dependência do spring de 3.0.0 para 3.0.5
bugfix - corrigida chamada do @PostConstruct nos componentes @ApplicationScoped quando usando o Spring como DI container
melhoria nas documentações
bugfix - redirect para @Path's com regexes
bugfix - Hibernate e JPA Transaction interceptors agora dão rollback quando existem erros de validação

3.3.0

Mudança de jars

troque google-collect 1.0rc por guava-r08
scannotations 1.0.2 agora é obrigatório

melhor integração com o Spring: agora os componentes do Spring podem acessar os do VRaptor e vice-versa
guice: @PostConstruct e @PreDestroy funcionando completamente
guice: todos os componentes request e session scoped são exportados para a view do mesmo jeito que com o spring (pelo nome da classe)
mudança da estratégia da ordem dos interceptors: agora é possível ordenar interceptors na anotação @Intercepts, dizendo quais interceptors devem rodar antes ou depois do interceptor anotado.
```
@Intercepts(before=AnInterceptor.class, after=AnotherInterceptor.class)
        
```
Assim o VRaptor executa os interceptors em uma ordem que respeita o before e o after de todos os interceptors. Desse modo a interface InterceptorSequence fica deprecada.
As anotações de verbos HTTP agora também podem definir o path do método:
```
@Get("/items/{id}"), @Post("/items"), etc
        
```
bugfix: @Transactional do Spring agora pode ser usado em qualquer classe (com as limitações do spring aop)
bugfix: upload de arquivos com mesmo nome
bugfix: web-fragments.xml no jboss 6
bugfix: melhor suporte para arrays como parâmetros
novas implementações de Download: ByteArrayDownload e JFreeChartDownload

nova view jsonp:

result.use(jsonp()).withCallback("oCallback").from(objeto).serialize();

que retorna

aCallback({"objeto": {...}})

removida a dependência direta com o commons-io
métodos do PageResult renomeados para ficarem consistentes com o resto do sistema
melhores logs de upload
refatoração nos converters do vraptor: agora eles usam o Localization para pegar o Locale e o bundle
removida classe Hibernate. Use validator.validate(objeto)
JSON serializado com indentação opcional.

3.2.0

várias melhorias na performance: por volta de 60% menos no tempo de requisição
quebra de compatibilidade interna: interface InterceptorStack reorganizada
melhor implementação do método accepts dos interceptors internos do VRaptor
suporte beta ao Google Guice, para ser usado ao invés do Spring
Pico provider não é mais deprecated
Agora é possível escolher o DI container sem precisar mudar o web.xml. Se os jars do Spring estiverem no classpath, o Spring será usado; se forem os jars do PicoContainer ele será usado, e da mesma forma pros jars do Guice. Os jars estão na pasta lib/containers do zip do VRaptor
quebra de compatibilidade interna: interfaces Converters, Router e construtor da classe PathAnnotationRoutesParser alterados. RouteBuilder convertido para interface => implementação DefaultRouteBuilder. Para quem estendia o RoutesParser basta trocar o delegate constructor. Para quem instanciava o RouteBuilder diretamente basta instanciar o DefaultRouteBuilder.

nova anotação @Lazy. Use-a nos interceptors em que o método accepts não depende do estado interno do interceptor:

@Intercepts
@Lazy
public class MeuLazyInterceptor implements Interceptor {
    public MeuLazyInterceptor(Dependencia dependencia) {
        this.dependencia = dependencia;
    }
    public boolean accepts(ResourceMethod method) {
        // depende apenas do method
        return method.containsAnnotation(Abc.class);
    }
    public void intercepts(...) {
        //...
    }
}

Nesse caso o MeuLazyInterceptor só será instanciado se o método accepts retornar true. Uma instância não funcional do MyLazyInterceptor será usada para chamar o método accepts, então esse método não pode usar o estado interno do interceptor. Não use o @Lazy se o método accepts for trivial (sempre retornar true)

pequena quebra de compatibilidade: prioridade padrão do @Path agora é Integer.MAX_INTEGER/2. Antes era Integer.MAX_INTEGER - 1. Apesar dessa quebra, acreditamos que isso não irá afetar os sistemas já implementados

prioridades do @Path agora podem ser definidas por constantes:

@Path(value="/url", priority=Path.HIGHEST)
@Path(value="/url", priority=Path.HIGH)
@Path(value="/url", priority=Path.DEFAULT)
@Path(value="/url", priority=Path.LOW)
@Path(value="/url", priority=Path.LOWEST)

Suporte a upload da Servlet 3.0 (por garcia-jj)

new Exception handlers (por garcia-jj)

result.on(SomeException.class).forwardTo(Controller.class).method();
//se uma SomeException é lançada, a requisição será redirecionada

Nova interface TwoWayConverter para conversões bidirecionais
suporte nativo a requisições OPTIONS
fix: 405 ao invés de 500 em requisições com HTTP metodo desconhecido
mais converters do Joda Time (por Rodolfo Liviero)
melhorias no Scala Blank Project (por Pedro Matiello)
bugfix: null Accept Header gera respostas html

3.1.3

Scala Blank Project
melhor estratégia no escopo flash
começo do suporte pra javax.inject API. Agora é possível dar nomes para os parâmetros de uma lógica:
Corrigidos bugs do novo validator
corrigido bug do char como parâmetro na URI
Corrigido bug para poder aceitar browsers que trabalham mal com o header Accepts
```
public void logica(@Named("um_nome") String outroNome) {...}
        
```
Nesse caso, o parâmetro aceito na requisição se chamará 'um_nome'.
Melhor suporte ao GAE
novo método no http result:
```
result.use(http()).body(conteudo);
        
```
conteudo pode ser uma String, um InputStream ou um Reader.
mais métodos disponíveis no result.use(status())
novo método : result.use(representation()).from(objeto, alias)

suporte a selects múltiplos:

public void logica(List<String> abc) {...}

<select name="abc[]" multiple="multiple">...</select>

status 406 automatico no result.use(representation())

Agora é possível registrar os componentes opcionais do vraptor no parâmetro packages do web.xml:

<context-param>
    <param-name>br.com.caelum.vraptor.packages</param-name>
    <param-value>
        br.com.caelum.vraptor.util.hibernate, // Session e SessionFactory
        br.com.caelum.vraptor.util.jpa, // EntityManager e EntityManagerFactory
        br.com.caelum.vraptor.converter.l10n, //Converters numericos localizados
        br.com.caelum.vraptor.http.iogi // suporte a parâmetros imutáveis
    </param-value>
</context-param>

renderizar null para sua representação significa retornar 404
nova classe: JsonDeserializer
MultipartInterceptor agora é opcional
bugfix: arrays de tamanho == 1 agora são suportados como parâmetros de lógicas
Pico provider deprecated
Validations agora usa o bundle (e locale) da requisição
ValidationMessage agora implementa Serializable
novo método: result.use(status()).badRequest(errorList); que serializa a lista de erros passada usando result.use(representation()).from(errorList, "errors");
atalhos no Validator:
```
validator.onErrorForwardTo(controller).logica();
validator.onErrorRedirectTo(controller).logica();
validator.onErrorUsePageOf(controller).logica();
        
```
onde controller pode ser uma classe ou o this, como acontece no Result. E ainda o atalho:
```
validator.onErrorSendBadRequest();
        
```
que retorna o status Bad Request (400) e serializa a lista de erros de validação de acordo com o header Accept da requisição (result.use(representation()))

3.1.2

Blank project agora rodando também no netbeans 6.8
Encoding agora suportado quando faz upload de arquivos no Google App Engine
bugfix: validator.onErrorUse(json()).... não dá mais NullPointerException
Serializers tem agora o método recursive:
```
result.use(xml()).from(meuObjeto).recursive().serialize();
        
```
Assim, toda a árvore de objetos a partir do meuObjeto será serializada.

Os parâmetros das mensagens do Validations agora também podem ser internacionalizados:

// idade = Idade
// maior_que = {0} deveria ser maior que {1}

validator.checking(new Validations() { {
    that(idade > 18, "idade", "maior_que", i18n("idade"), 18);
    //resulta na mensagem "Idade deveria ser maior que 18"
}});

Proxies do Hibernate agora são serializados (quase) como classes normais (graças ao Tomaz Lavieri)

Ao serializar para json agora é possível excluir o root (graças ao Tomaz Lavieri):

result.use(json()).from(carro).serialize(); //=> {'carro': {'cor': 'azul'}}
result.use(json()).withoutRoot().from(carro).serialize(); //=> {'cor': 'azul'}

Google collections atualizado para a versão 1.0
corrigido bug das chaves dentro de expressões regulares dentro do @Path
as anotações do XStream agora são lidas automaticamente quando você usa a serialização padrão do vraptor
quando um arquivo é maior do que o limite de tamanho de arquivo é criado um erro de validação ao invés de uma exceção genérica

mais atalhos na interface Result:

redirectTo("uma/uri")          =>  use(page()).redirect("uma/uri")
notFound()                        =>  use(status()).notFound()
nothing()                     =>  use(nothing());
permanentlyRedirectTo(Controller.class)
        => use(status()).movedPermanentlyTo(Controller.class);
permanentlyRedirectTo("uma/uri")  => use(status()).movedPermanentlyTo("uma/uri");
permanentlyRedirectTo(this)     => use(status()).movedPermanentlyTo(this.getClass());

adicionado novo método à interface Validator (graças ao Otávio Garcia)
```
validator.validate(objeto);
        
```
Esse método vai validar o objeto usando o Hibernate Validator 3, a Java Validation API (JSR303), ou qualquer implementação da interface BeanValidator anotada com @Component

novos converters de BigDecimal, Double e Float, que levam em consideração o Locale para converter os valores (graças ao Otávio Garcia). Para usá-los basta adicionar ao web.xml:

<context-param>
    <param-name>br.com.caelum.vraptor.packages</param-name>
    <param-value>!!valor anterior!!,br.com.caelum.vraptor.converter.l10n</param-value>
</context-param>

3.1.1

VRaptor 3 publicado no repositório central do maven!

<dependency>
    <groupId>br.com.caelum</groupId>
    <artifactId>vraptor</artifactId>
    <version>3.1.1</version>
</dependency>

nova implementação do Outjector. Agora quando acontecem erros de validação os objetos populados são replicados para a próxima requisição, e não mais os parâmetros do request, prevenindo class cast exceptions nas taglibs
fixados alguns bugs da compatibilidade com o VRaptor 2

3.1.0

agora é possível serializar coleções usando result.use(xml()) e result.use(json())
novo escopo @PrototypeScoped, que cria sempre uma nova instância da classe anotada cada vez que ela for requisitada
nova view: result.use(Results.representation()).from(objeto).serialize(); Essa view tenta descobrir o formato da requisição (via _format ou o header Accept) e renderizar o objetodado nesse formato. Por enquanto apenas xml e json são suportados, mas é possível criar serializadores para qualquer formato. Se o formato não foi passado ou ele não é suportado, o jsp padrão vai ser mostrado
bugfix: os parâmetros agora são passados via array no escopo Flash, então tudo vai funcionar como deveria no GAE
bugfix: agora o validator.onErrorUse(...) funciona com todos os Results padrão
bugfix: retornar um Download/File/InputStream null não dá mais NullPointerException se já houve algum redirecionamento (result.use(...))
bugfix: result.use(page()).redirect("...") agora inclui o contextPath se a url começar com /

bugfix: agora é possível criar Controllers genéricos:

public class ClientesController extends GenericController<Cliente> {

}
public class GenericController<T> {
    public T mostra(Long id) {...} // a variável da view vai se chamar t
    public void adiciona(T obj) {...} // os parâmetros da requisição vão ser obj.campo
}

você pode anotar sua classe controller com @Path, e todas as URIs dos métodos vão incluir o prefixo especificado.

@Resource
@Path("/prefixo")
public class MeuController {
    //URI: /prefixo/umMetodo
    public void umMetodo() {...}

    //URI: /prefixo/relativo
    @Path("relativo")
    public void pathRelativo() {...}

    //URI: /prefixo/absoluto
    @Path("/absoluto")
    public void pathAbsoluto() {...}
}

@Path agora aceita regexes: @Path("/abc/{abc:a+b+c+}") vai aceitar as URIs do tipo:
```
/abc/abc
/abc/aaaaabbcccc
/abc/abbc
        
```
ou seja, onde o parâmetro casa com a regex a+b+c+
Foram criados atalhos na interface Result para as operações mais comuns:
- result.forwardTo("/uma/uri") ==> result.use(page()).forward("/uma/uri");
- result.forwardTo(ClienteController.class).lista() ==> result.use(logic()).forwardTo(ClienteController.class).lista();
- result.redirectTo(ClienteController.class).lista() ==> result.use(logic()).redirectTo(ClienteController.class).lista();
- result.of(ClienteController.class).lista() ==> result.use(page()).of(ClienteController.class).lista();
Além disso, se o redirecionamento é para um método do mesmo controller, você pode usar:
- result.forwardTo(this).lista() ==> result.use(logic()).forwardTo(this.getClass()).lista();
- result.redirectTo(this).lista() ==> result.use(logic()).redirectTo(this.getClass()).lista();
- result.of(this).lista() ==> result.use(page()).of(this.getClass()).lista();
VRaptor agora scaneia por componentes e recursos em todo WEB-INF/classes automaticamente sem configuracao
Suporte a Servlet 3.0, fazendo desnecessário configurar o filtro no web.xml (usando recurso de webfragments)
Jars do spring atualizados (3.0.0) e do hibernate também, para os projetos de exemplo. Google Collections atualizada para 1.0
Blank project atualizado para WTP mais novo e refletindo novidades do VR 3.1
Blank project muito mais fácil de se importar no Eclipse WTP. Configurações e logging ajustados para melhor compreensão
bugfix: mimetypes funcionam corretamente para browsers webkit, favorecendo html quando nao ha priorizacao
bugfix: quando há erros de validação, os parâmetros da requisição são passados como String, não como mapas como antes. Isso previne ClassCastExceptions quando se usa taglibs, como a fmt:formatNumber.

3.0.2

suporte a containers servlet 2.4, como Oracle Container 10.1.3.1
bugfix: Results.referer() agora implementa View
bugfix: content-type agora é exposto pelo File/InputStream Download
removida chamadas a api de Java 6
novos providers, baseados no Spring: HibernateCustomProvider e JPACustomProvider. Esses providers já registram os componentes opcionais do Hibernate ou da JPA
bugfix: os converters agora não jogam exceções quando não existe um ResourceBundle configurado
bugfix: o retorno do método agora é incluido no result quando acontece um forward
bugfix: os parâmetros da requisição são mantidos quando acontece um erro de validação.
bugfix: lançando exceção quando o paranamer não consegue achar os metadados dos parâmetros, assim é possível se recuperar desse problema

suporte inicial à serialização de objetos em xml e json:

result.use(Results.json()).from(meuObjeto).include(...).exclude(...).serialize();
result.use(Results.xml()).from(meuObjeto).include(...).exclude(...).serialize();

3.0.1

paranamer atualizado para versão 1.5 (Atualize seu jar!)
jars separados em opcional e obrigatório no vraptor-core
dependências estão explicadas no vraptor-core/libs/mandatory/dependencies.txt e no vraptor-core/libs/optional/dependencies.txt
possibilidade de setar o character encoding da aplicação no web.xml através do context-param br.com.caelum.vraptor.encoding
nova view: Referer view: result.use(Results.referer()).redirect();

Escopo Flash:

result.include("umaChave", umObjeto);
result.use(logic()).redirectTo(UmController.class).umMetodo();

objetos incluidos no Result vão sobreviver até a próxima requisição quando acontecer um redirect

@Path suporta vários valores (String -> String[]) ex @Path({"/client", "/Client"})
Result.include agora retorna this para uma interface fluente (result.include(...).include(....))
Melhor mensagem de exception quando não encontra o Http method requisitado
File Download registra automaticamente content-length
Bug 117 resolvido: expondo null quando retorna null (antes era "ok")
Bug 109 resolvido: se você tem um arquivo /caminho/index.jsp, você consegue acessá-lo agora via /caminho/, a menos que exista algum controller que trata essa URI
Quando existe uma rota que consegue tratar a URI da requisição, mas que não aceita o HTTP method da requisição, o VRaptor vai retornar um HTTP status code 405 -> Method Not Allowed, ao invés do 404
Uma grande refatoração na API interna de rotas

3.0.0

ValidationError foi renomeado para ValidationException
result.use(Results.http()) para setar headers e status codes do protocolo HTTP
Correção de bugs
documentação
novo site

3.0.0-rc-1

aplicação de exemplo: mydvds

novo jeito de adicionar os componentes opcionais do VRaptor:

public class CustomProvider extends SpringProvider {

    @Override
    protected void registerCustomComponents(ComponentRegistry registry) {
        registry.registry(ComponenteOpcional.class, ComponenteOpcional.class);
    }
}

Utils: HibernateTransactionInterceptor e JPATransactionInterceptor
Um exemplo completo de aplicação na documentação
Docs em inglês

3.0.0-beta-5

Novo jeito de fazer validações:

public void visualiza(Cliente cliente) {
    validator.checking(new Validations() { {
        that(cliente.getId() != null, "id", "id.deve.ser.preenchido");
    }});
    validator.onErrorUse(page()).of(ClientesController.class).list();

    //continua o metodo
}

UploadedFile.getFile() agora retorna InputStream
EntityManagerCreator e EntityManagerFactoryCreator
bugfixes

3.0.0-beta-4

Novo result: result.use(page()).of(MeuController.class).minhaLogica() renderiza a view padrão (/WEB-INF/jsp/meu/minhaLogica.jsp) sem executar a minhaLogica
Classes Mocks para testes: MockResult e MockValidator, para facilitar testes unitários das lógicas. Eles ignoram a maioria das chamadas e guardam parâmetros incluídos no result e erros de validação
As URIs passadas para result.use(page()).forward(uri) e result.use(page()).redirect(uri) não podem ser URIs de lógicas, usem os forwards e redirects do result.use(logic())
Os parâmetros passados para as URIs agora aceitam pattern-matching:
- Automático: se temos a URI /clients/{client.id} e client.id é um Long, o parâmetro {client.id} só vai casar com números, ou seja, a URI /clients/42 casa, mas a uri /clients/random não casa. Isso funciona para todos os tipos numéricos, booleanos e enums, o vraptor vai restringir para os valores possíveis.
- Manual: no CustomRoutes você vai poder fazer:
```
routeFor("/clients/{client.id}").withParameter("client.id")
                                .matching("\\d{1,4}")
                                .is(ClienteController.class).mostra(null);
                
```
  ou seja, pode restringir os valores para o determinado parâmetro via expressões regulares no método matching.
Converters para LocalDate e LocalTime do joda-time já vêm por padrão
Quando o Spring é usado como IoC Provider, o VRaptor tenta buscar o spring da aplicação para usar como container pai. A busca é feita por padrão em um dos dois jeitos:
- WebApplicationContextUtils.getWebApplicationContext(servletContext), para o caso em que você tem os listeners do Spring configurados.
- applicationContext.xml dentro do classpath
Se isso não for o suficiente você pode implementar a interface SpringLocator e disponbilizar o ApplicationContext do spring usado pela sua aplicação
Utils:
- SessionCreator e SessionFactoryCreator para disponbilizar a Session e o SessionFactory do hibernate para os componentes registrados.
- EncodingInterceptor, para mudar o encoding da sua aplicação.
correção de vários bugs e melhorias na documentação.

3.0.0-beta-3

O Spring é o Provider de IoC padrão
o applicationContext.xml no classpath é usado como configuração incial do spring, caso exista
a documentação http://vraptor.caelum.com.br/documentacao está mais completa e atualizada
pequenos bugs e otimizações

Documentação