Sorry, this entry is only available in Português.
Globalizing jQuery validation with ASP.NET MVC 3
ASP.NET MVC 3 has a great feature which is client validation using jQuery plugin’s jQuery validations and using a Microsoft script the validation is made without the need of any other special code. You just have to use the attributes from System.ComponentModel.DataAnnotations namespace.
For those who don’t know, to use this validation you just need to add the following script references (which are included in the default template when a new Asp.Net Mvc 3 gets created):
<script src=”/Scripts/jquery-1.6.2.min.js” type=”text/javascript”></script>
<script src=”/Scripts/jquery.validate.min.js” type=”text/javascript”></script>
<script src=”/Scripts/jquery.validate.unobtrusive.min.js” type=”text/javascript”></script>
Pretty simple actually! But there is an issue, this script is not globalized. So, let’s say you have an attribute inside your class of the DateTime type and you’d like to validate it, for instance, I had a class which among other things had a DateTime. Just to make things simples, it was something like this:
1 2 3 4 5 6 7 8 9 10 11 12 | public class Person { public string Name { get; set; } public string Sex { get; set; } public string Rg { get; set; } [DataType(DataType.EmailAddress)] public string Email { get; set; } [DataType(DataType.Date)] public DateTime? BirthDate { get; set; } } |
So when a filled a form with the date 16/09/1980, for instance, automatically it was detected as an invalid date, since the expected is a date using the pattern mm/dd/yyyy, but of course, here in Brazil the pattern is different, it is dd/mm/yyyy.
So how can I fix it?
First of all, I have to use the jQuery’s plugin Globalize. I just have to add references to two scripts.
<script type=”text/javascript” src=”@Url.Content(“~/Scripts/globalize.js”)”></script>
<script type=”text/javascript” src=”@Url.Content(“~/Scripts/cultures/globalize.culture.pt-BR.js”)”></script>
After that, all it has to be done is set the desired culture and write a small function to parse the date using the Globalize parseDate function:
1 2 3 4 | Globalize.culture("pt-BR"); $.validator.methods.date = function(value, element) { return this.optional(element) || Globalize.parseDate(value); }; |
It couldn’t be more simple!
Criando Snippets para o Visual Studio 2010
Motivação
Apesar de ser e gostar muito de ser um desenvolvedor, sou totalmente a favor de escrever a menor quantidade de código possível. Porque menos código, geralmente quer dizer menos erros. Com isso em mente eu resolvi criar Snippets de código no Visual Studio 2010. Você pode até não saber o que é um snippet mas com certeza já usou um. Um snippet é uma pequena porção de código que é reutilizável. Por exemplo, entre no seu Visual Studio, e dentro de um método digite foreach e aperte Tab. Pronto, isso é um snippet.
Seguindo essa mentalidade e fazendo testes unitários eu me peguei escrevendo diversas vezes esse código:
1 2 3 4 5 | [Test] public void Meuteste() { } |
Meu objetivo era que digitasse apenas um comando de atalho (nesse caso escolhi ntest) e que esse código fosse gerado pra mim, permitindo que eu apenas alterasse o nome do método.
Snippet Designer
O Visual Studio 2010 permite que você crie snippets através do seu editor de XML, que é o padrão, afinal de contas um snippet nada mais é do que um arquivo xml. Mas existe uma extensão para o VS2010 chamada Snippet Desiner que facilita um pouco o trabalho. Então vá em Tools –> Extension Manager e adicione a extensão.
Criando o Snippet
Crie um novo projeto no VS2010 e adicione um arquivo do tipo XML. Dê o nome que quiser, mas use a extensão .snippet. No meu caso o nome do arquivo é NUnitTest.snippet.
Ao criar o arquivo ele estará vazio e, portanto, o Snippet Designer não irá abri-lo. Clique com o botão direito no arquivo e me Open With, selecione o XML (Text) Editor e clique em OK.
Dentro do documento XML clique com o botão direito e selecione a opção Insert Snipet
Em seguida selecione a opção Snippet.
O xml necessário para a criação do snippet será gerado, como você pode perceber ele mesmo é um snippet. #inception #feelings 
É possível editar ali mesmo o xml, ou então podemos usar o Snippet Designer que acabos de instalar. Salve o arquivo e feche-o. No Solution Explorer, mais uma vez clique com o botão direito no arquivo e em Open With e dessa vez selecione a opção Snippet Desiger, uma tela como a abaixo deverá aparecer.
Algumas coisas que precisam ser alteradas, no topo do lado esquerdo, dê um título e selecione a linguangem, no meu caso foi NUnit Test e C#. As proprieades do arquivo são bem claras, mas o que você deve ter uma atenção é pra propriedade Shortcut. O que você colocar ali é o que você vai digitar antes do Tab na hora de codificar. Eu preenchi o meu como ntest.
Na parte de baixo é onde você define a parte do código que é customizável quando você fica dando tabs no seu snippet, no meu caso eu queria customizar apenas o nome do método, então alterei o item que vem ali para testName e deixei campo Defaults to para testName também.
Por fim, a principal e maior parte da tela é onde você coloca o seu código do snippet, apenas preencha o código que você quer ali normalmente e substituia a parte customizável pelas variáveis que você criou, prestando atenção que o nome dessa variável deve estar entre $$, assim: $testName$. Veja como ficou meu snippet após as mudanças.
Utilizando o Snippet
O VS2010 usa diversos snippets, mas obviamente é muito fácil adicionar aqueles que foram criados pelos usuários. Basta carregar os arquivos .snippet criados por você dentro dele.
Por padrão quando se instala o VS2010 ele cria uma pasta dentro da pasta Meus Documentos chamada Visual Studio 2010, ali navegue para –> Code Snippets –> Visual C# –> My Code Snippets. Copie o(s) arquivo(s) .snippet que você criou e cole dentro dessa pasta. Isso é claro, considerando que são snippets de C#, caso contrário coloque na pasta correta.
É provável que tudo já esteja funcionando, mas para ter certeza, dentro do VS2010 vá em Tools –> Code Snippets Manager, selecione a linguagem e deve aparecer algo assim.
Se não aparecer ali, basta clicar em Add, navegar e selecionar a pasta onde estão os arquivos .snippet. Pronto! Isso é tudo que você precisa.
Agora é só testar. Vá até uma classe, digite ntest e aperte Tab. O código do snippet deve aparecer e o cursor deve estar posicionado no nome do método, pronto para que este seja alterado.
Finalizando
O snippet que eu criei é bem simples, mas de um código que eu faço toda hora, se você tem alguma coisa desse tipo e quer facilitar, esse é o caminho.
O código desse projeto está diposnível para download aqui.
Análise: Growing Object-Oriented Software, Guided by Tests
Eu acabei de ler Growing Objected-Oriented Software, Guided by Tests e posso dizer que é um livro altamente recomendável.
Para quem está interessado em começar, ou já começou e quer apefeiçoar a prática de desenvolver software usando testes antes de escrever o “código de produção”, é um ótimo livro.
Testing is no longer just about keeping defects from the users; instead, it’s about helping the team to understand the features that users need and to deliver those features reliably and predictably.
Após duas partes teóricas, o livro, na terceira parte, começa a ficar mais prático.
A terceira parte do livro se passa toda desenvolvendo um exemplo e realmente evoluindo uma aplicação aos poucos. Exemplo feito em Java, mas que nada atrabalha para quem não conhece muito da linguagem. Além disso, é ótimo seguir a linha de pensamento dos autores e ver como eles enxergam a evolução de um software orientado a objetos. E uma das melhores partes de sistema de exemplo, é que ele não fica no básico, muito pelo contrário, traz problemas do “mundo real”, como interação com serviços externos e testes de interface de usuário.
Embora a terceira parte seja ótima, é na quarta parte onde o livro realmente mostra seu valor. A quarta parte fala de desenvolvimento orientado a testes de forma sustentável, tratando de assuntos como: quando usar objetos mock ou não, facilitar a leitura e o entendimento dos testes, construção de objetos complexos necessários aos testes, entre outros.
Ainda existe um capítulo muito interessante que fala sobre testes na camada de persistência a dados, uma parte que eu sempre achei complexa de se testar. Ali, encontrei dicas valiosas.
Uma ótima leitura, recomendo!
O livro eletrônico é só vantagem
Se você ainda não se convenceu de que os livros eletrônicos são uma boa opção ou mesmo uma realidade hoje em dia, quem sabe a lista de vantagens abaixo possa te ajudar.
Eu virei um fã e um adepto dos livros eletrônicos, sério, acho pouco provável eu comprar um livro em papel novamente (havendo a opção eletrônica) e principalmente se for técnico.
Veja só se essa lista te ajuda:
- geralmente são mais baratos
- se você compra livros em papel on-line paga frete, nos eletrônicos, obviamente não
- você não precisa esperar que eles cheguem pelo correio
- já existem diversos livros em português e podem ser comprados em sites brasileiros como Saraiva e Cultura
- se você gosta de anotar nos livros, existe um software da Amazon, o Kindle que permite marcar e anotar nos textos
- você não precisa comprar um Tablet ou E-Reader para ler seus livros eletrônicos, esse mesmo software do Kindle está disponível para diversas plataformas, inclusive celulares
- se você tiver um E-Reader ou Tablet, pode levar todos os seus livros com você e existem diversos no mercado
- se você não quiser comprar um E-Reader e tiver um smartphone também é possível. Eu tenho um Samsung Galaxy S com Android e a leitura é muito boa e tranquila, o maior problema é pra ler código ou ver imagens, quando é só texto, vai bem.
- é ecologicamente correto
A maior desvantagem do livro eletrônico é que não é possível expo-lo em uma instante, bom, pelo menos não em uma real porque na virtual já dá.
Saving unfinished changes with Git
The more I use Git, the more I like it. Fact.
You know when you are in the middle of something, it is not done yet, and someone call you with a bug for you to fix it? What do you do with your unfinished business?
Git has a command called stash. Stash is a separated area from your commits, which purpose is exactly that, to save unfinished work. And its use is very simple.
git stash save
This command saves the changes in the current working directory and clears the log to your last commit.
For instance, let’s say you have a project with a version 1 already done and you are in the middle of version 2, and of course, you have created a branch for that.
Then, while you are in the middle of another feature, there’s a bug to fix in version 1. Your git status at this moment would look like this:
You can’t commit yet, because if you do that, the build will break, and your are to much of a responsible guy to do that, aren’t you? So what to do?
Here’s when git stash comes to play. With the command: git stash save – you’ll have the following result:
The buffer gets cleared, and you now can checkout version 1.0, fix the bug, commit it, get back to version 2.0 and rebase it.
When you reach that point just executes command: git stash pop – to get your unfinished changes back.
Done, your back in the game, exactly were you left it.
There are a lot more options within stash command. I recommend you take a look at git’s documentation.
Ruby for .NET Developers – part 2
This is a serie of articles about Ruby for .NET developers, check the others:
Ruby, is an object oriented language, and you will recognize, with some differences in the syntaxe and some other similarities compared to C#.
You may see, in the bellow code, a class definition (User), a constructor, which is the initialize method. There’s also a method definition (access_authorization) and two attributes, name and email.
1 2 3 4 5 6 7 8 9 10 11 | class User attr_accessor :name, :email def initialize(name) @name = name end def access_authorization false end end |
What is different so far, is that when method attr_accessor is called it creates the properties name and email, and internally Ruby creates two instance variables called @name and @email and these variables may, obviously, be accessed within any method in that object.
By the way, to create an instance of User class it is as simple as:
user = User.new
Returning values
One other important thing to remember in Ruby, is that the result of the last instruction is always returned. Therefore inside the access_authorization method, the value false is been returned. Using false as a last instruction (and in this case, the only one) is the same think as using: return false.
For instance, the both methods bellow do the same thing:
1 2 3 4 5 6 7 8 9 10 | def sum(x, y) # does a lot of unnecessary stuff here x + y end def sum(x, y) # does a lot of unnecessary stuff here sum_result = x + y return sum_result end |
In both cases, x is summed to y and the result is returned.
Inheritance
Just like in C#, Ruby also have inheritance as we may see in code bellow:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | class User attr_accessor :name, :email def initialize(name) @name = name end def access_authorization false end end class SpecialUser < User def access_authorization true end end |
In the above code the SpecialUser class inherits from the User class and overrides the method access_authorization.
Static Methods
Ruby doesn’t really has static methods, but it has, as it is known class methods and they work similarly as static methods in C#. To use static methods, when declaring the method just use the self keyword, as we may see:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | class SpecialUser < User def self.save send_email("email text here") #save user data end def access_authorization true end private def send_email(txt) # send email end end |
The save method can be called directly from the SpecialUser class. It is not needed to create an instance of the class.
SpecialUser.save
Still in the above code, we may see that, declaring a private method it is as simple as adding the private keyword and every method declared bellow it will be considered private.
Interfaces
Interfaces are a static typed language resource to tell the compiler that a class has one or more given methods.
In Ruby there is no compiler, therefore the code is not checked for method implementation. Also, there is the important matter that we may change Ruby’s classes even after they are declared, but we’ll talk about that later. So, there are no need for interfaces in Ruby.
Let’s say there’s the following situation done using C#:
1 2 3 4 5 6 7 8 9 10 11 12 | interface IPaymentManagement { void Pay(); } class Pay : IPaymentManagement { public void Pay() { // payment strategy } } |
This code is pretty straightforward, it tells the compiler the class Payment implements the methods of IPaymentManagement interface. In Ruby, the only thing we need to do is actually implement the method Pay().
1 2 3 4 | class Payment def pay end end |
This has pros and cons.
One benefit is the Ruby code is much more succinct and objective, it is not need to write code only to make the compiler happy. There is only code that solves the business problem.
The downside is you don’t have the compilers feedback in case the method is not implemented.
Still, if you are a follower of technics such as TDD, this is an easy issue to fix, as your tests would be responsible for that.
Another resource available in Ruby is, every class automatically inherits from class Class, in class Class there is a method respond_to?. This method tells if an object responds to a specific method.
In the above code the class ControlePagamento has been defined without the “pagar” method, when the method respond_to? was called the return was false.
But, bellow the method was defined and the response was true.
Anyway, there many options to control it and there people that does it, but worth noticing what I am seeing, the usual way is just to follow a convention.
Conclusion
In this article we saw some more important differences in Ruby, in the next article I’ll be talking about Ruby’s Object Model.
Doubts, critics and suggestions? Leave a comment.
Ruby para desenvolvedores .NET–parte 1
Eu tenho usado Ruby já há algum tempo, principalmente em alguns desenvolvimentos pessoais usando o Rails. Mas eu trabalho com C# já há mais de 8 anos e vivi fechado nesse mundo .NET por muito tempo, muito mais do que eu gostaria. De qualquer forma, ruby já tem feito parte do meu dia a dia, então eu gostaria de compartilhar algumas coisas que já aprendi sobre ruby, para aqueles, que como eu, vivem no mundo .NET.
Motivação
Ruby é e deve ser considerada uma linguagem de primeira classe, é possível hoje realizar aplicativos de diversos fins com Ruby e não somente aplicações web usando Rails. Mas, muitas vezes as empresas preferem ficar com linguagens mais conhecidas no mercado como Java ou C# para suas aplicações.
Ok, se você não pode usar Ruby para construir suas aplicações é bem provável que possa usar Ruby como uma linguagem de scripting (que ela é), para ajudar em trabalhos marginais porém importantes que muitas vezes não são feitos, ou são feitos usando outras coisas como XML, como por exemplo realizar Builds e Deploys, fazer testes de aplicativos, entre outros.
Se você pode escolher qual a linguagem quer usar, melhor pra você, Ruby pode ser uma ótima escolha, como veremos.
Interpretador
A primeira coisa que precisamos para usar Ruby é um interpretador de Ruby. Existem vários interpretadores por ai, o que eu vou usar aqui é o IronRuby. O IronRuby é um interpretador do Ruby que permite usar Ruby sobre a plataforma .NET, ou seja, vai permitir que você use os assemblies que já está costumado. É Ruby, segue a especificação de Ruby, com o adicional do .NET. Ótimo não é?
Eu recomento instalar a versão 1.0 que é compatível com o Ruby 1.8.7, andei fazendo uns testes com a versão 1.1 do IronRuby e ainda dá vários paus (pelo menos na data atual). A vantagem dessa versão 1.1 é que ela já vem com ferramentas para o Visual Studio 2010.
O Console
Uma vez com o IronRuby instalado, você deve ter o IronRuby Console no seu menu iniciar, ou então pode executar o console a partir de um prompt padrão com o comando iirb.
O console permite que você execute qualquer instrução ruby, vá e faça um teste simples:
Uma outra vantagem do Ruby é a “falta de cerimônia” no código como os {}, ;, () e afins. Aliando isso ao fato de ser uma linguagem interpretada, veja a diferença de um Hello World feito em C# para uma aplicação console e uma em Ruby.
1 2 3 4 5 6 7 8 9 10 11 | using System; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { Console.WriteLine(string.Format("Hello World, {0}", args[0])); } } } |
E agora em Ruby:
1 | puts "Hello World, #{ARGV[0]}" |
Considere, que além da diferença da linguagem, para rodar o aplicativo no .NET é preciso compilar, gerar um executável e então rodá-lo. E para rodar o script Ruby, considerando que ele foi salvo num arquivo chamado hello_world.rb basta executar o comando:
Fortemente, Estaticamente e Dinamicamente tipado
Falando da linguagem realmente, Ruby é uma linguagem fortemente e dinamicamente tipada. O que isso quer dizer?
Quer dizer as variáveis tem um tipo bem definido, por exemplo uma variável do tipo String não pode ser somada a uma variável do tipo Fixnum veja:
Veja que apenas por atribuir um valor às variáveis os tipos foram definidos como Fixnum e String, isso é definir uma tipagem dinamicamente, ou seja, no seu primeiro uso. Nos casos acima as variáveis texto e numero são instâncias das classes String e Fixnum respectivamente e por isso tem acessos aos seus métodos, então se você quiser concatenar as duas variáveis em uma string pode fazer o seguinte:
Veja que chamei o método to_s que converte para string e então foi gerado o texto “VinTem12”
Linguagens, estaticamente tipadas, como o C#, tem seu tipo definido em tempo de compilação, ou seja, antes da execução.
Usando o .NET
Como um exemplo simples de como é possível usar as classes do .NET a partir do IronRuby, vou mostrar um código básico de um MessageBox do Windows Forms.
O princípio é o mesmo para qualquer classe do .NET Framework. 
Concluindo
Essa foi apenas uma apresentação inicial de como instalar um ambiente Ruby no Windows, do console do Ruby e da diferença mais básica entre Ruby e C# que é a tipagem.
Nos próximos vou falar um pouco mais a fundo das características do Ruby e quais as diferenças para o C#.
Convertendo um texto ISO-8859-1 para UTF-8 em Ruby
No Ruby 1.9 uma coisa que você pode ter certeza é que terá dor de cabeça é com Encoding. Faça uma busca rápida no google por “ruby 1.9 encoding” e você vai entender do que eu estou falando.
Hoje eu tive que converter um conteúdo que estava em iso-8859-1 para utf-8 e recebi o seguinte erro:
incompatible character encodings: UTF-8 and ISO-8859-1
Para resolver isso eu usei:
1 | "meu texto".encode("UTF-8", undef: :replace, invalid: :replace) |
E o problema foi resolvido. Segundo a documentação do Ruby 1.9 o parâmetro :invalid com o valor :replace, faz com que o método encode substitua o carácter inválido. O padrão é gerar uma exceção.