Criando versões

Este post não é sobre código, mas um ponto de vista sobre criar versões de sistemas.

Uma das piores coisas que se tem é ter um projeto que logicamente é dividido em modulos, mas fisicamente é um bloco de código comportando todos estes modulos.
As requisições, os testes, as versões são sempre em modulos, mas a implementação do código é feito tudo em bloco.

Como assim em bloco?

Imagine um projeto que comece com a visão de funcionalidades simples:

"Uma pessoa realiza um atendimento, depois passa para um processo de cadastro e por fim gerar um certificado."
Processo simples... Um projeto WEB feito em camada no melhor estilo MVC resolve o problema, certo? Errado.

Conforme o sistema vai crescendo, são acrescentados outros modulos conforme a vontade do cliente ou foi planejado por uma equipe de analise, mas não repassado ao arquiteto ou os desenvolvedores para uma analise de como iniciar a arquitetura do projeto. Desta forma vai entrando um modulo de cada vez e aquele bloco pequeno vai crescendo até num determinado momento em que seria melhor trocar para um estilo mais em modulos, como ficou definido logicamente.

Infelizmente é tarde! Não é mais possível trocar, pois o projeto cresceu de uma determinada maneira que se parar para trocá-lo pode demorar um tempo considerável que o cliente pode não aceitar esta "perda de tempo" (o sistema está rodando, por que alterar) ou fica inviável devido a complexidade das regras que o projeto se tornou.
Aquele pequeno inicio utilizando o padrão MVC já não serve mais, precisa ser um sistema mais "plugavel", que comporte a entrada de modulos e tenha uma implementação independente. Pena que só quando chega a um ponto deste é que percebemos que deveriamos fazer este sistema "plugavel" desde o inicio, mas quem poderia prever isto? A turma inicial de analise poderia, mas geralmente esta turma fica mais voltada para a venda que para eles é tudo uma coisa só. Não existe estruturas interna, apenas telas para serem exibidas e suas regras de negócios.

Por este ponto de vista, continuar projetos que já estão com uma estrutura definida e este não se encaixa ao modelo de "plugável" precisa de muita paciência para gerar suas versões de disponibilização conforme o modelo lógico de separação em modulos. Seria interessante o quanto antes alterar o projetos para um padrão em modulos e para projetos novos já planejar a estrutura para comportar os modulos, mesmo que seja apenas um.

Aprofundando um pouco em Javascript

Javascript está ficando uma linguagem muito legal para programar (Quem sabe um dia chega ao modelo de programação do Ruby... Sonho), mas já começa a despertar as maneira de programas em forma de Orientação a Objetos com suas funcionalidades.

Já fiz diversas coisas com a utilização do Prototype e esta é outra que ajuda na formatação de números decimais. Devem haver diversos outros scripts que fazem a mesma coisa, mas gostei do meu, pois é o primeiro que eu realmente uso Javascript como OO.

A utilização ficou simples

<input onblur="Decimal.format(this, '3#0,00')" type="text" />

Coloquei na perda de foco do campo, mas pode ser colocado em outro lugar (vai da sua cabeça)

O modelo de padrão que estou utilizando é
3#0,00

Onde:
'3' é o número de campos opcionais a frente do primeiro 0
'#' é o símbolo de campos opcionais, se vier só ele a quantidade de opcionais é 1 o número na frente é seu multiplicador
'0,00' é o padrão que deve ser aplicado. Considero a utilização de um campo a frente, um separador que pode ser ',' ou '.' e a quantidade de casas decimais.
Alguns modelos:

entrada	padrão	resultado
123	0,00	1,23
12345	2#0,0	123,4
12345	2#0,00	123,45
12,3401	2#0,00	12,34
12.56	#0,00	12,56
120,00	#0.00	12.00

Segue o código:

var Decimal = Class.create();
Decimal.format = function(field, pattern, notEmpty) {
    
    if(field.value == "" && notEmpty) {
        field.value = "0";
    }
    
    var decimal = new Decimal(field, pattern);
    decimal.applyPattern();
}
Decimal.prototype = {
 initialize: function(field, pattern) {
  this.field = field;
  this.pattern = pattern;
 },

 applyPattern: function() {

  if(this.field.value == "") {
    return; 
  }

  var expressionPattern = new RegExp("([1-9]){0,1}(#){0,1}(0)([,\\.]{0,1})(0*)");
  var expressionValue = new RegExp("([0-9]*)[,\\.]{0,1}([0-9]*)");
  
  var resultPattern = expressionPattern.exec(this.pattern);
  var resultValue = expressionValue.exec(this.field.value);
  
  var separatorPosition = 0;
  var result = "";
  
  resultPattern[1] = !resultPattern[1] || resultPattern[1].length == 0 ? 1 : parseInt(resultPattern[1]);
  resultPattern[2] = !resultPattern[2] || resultPattern[2].length == 0 ? 0 : 1;
  
  var totalValue = (resultPattern[1] * resultPattern[2]) + 1;
  
  if( (!resultValue[1] || resultValue[1].length == 0) && (!resultValue[2] || resultValue[2].length == 0) ) {
         alert("Formato inválido para o número");
         this.field.value = "";
         return;
  }
  
  resultValue[1] = resultValue[1].length == 0 ? "0" : resultValue[1];
  
  
  for(var i = 0; i < resultValue[1].length; i++) {
            if (i == totalValue) {
                separatorPosition = i;
             result += resultPattern[4];
      }

      if (i < (totalValue + resultPattern[5].length)) {
          result += resultValue[1].charAt(i); 
         }
  }
  
  if(result.length <= totalValue) {
         separatorPosition = result.length;
         result += resultPattern[4];
  }
  
  var j = 0;
  for(var i = separatorPosition; i <= (separatorPosition + resultPattern[5].length);i++) {
      if(result.length <= (separatorPosition + resultPattern[5].length) ) {
          var eachValue = resultValue[2].charAt(j++)
          if(eachValue && eachValue != "") {
              result += eachValue;
          } else {
                 result += "0";
          }
      }
  }
  
        this.field.value = result;
 }
}

Ainda não fiz testes completos, mas está funcionando até o ponto que testei, se pintar algum problemas posto a correção aqui. :D