Rolling With Code

Foreman

2011-08-31T05:22:00.000-07:00

I've watched the RailsCasts #281, and Ryan Bates is talking about the Foreman gem. At the first time I did not mind for the project, this is interesting, but I don't see how it's can be useful for me. Then I go back to the project when I'm working. I open my iTerm, an tab for mongod, and tab for spork, and a tab for guard, and another to run the generators.
After I open all this tabs, Foreman gem cames to my mind. Well, I gave to Foreman a opportunity, and I loved it.

If you think this scenario is the same of you, take a look at Foreman, and give to it a chance.
You can add the gem to your Gemfile or install it by your own hand. To work foreman only needs a file called Procfile. in this manifest file, you name your process and tell to foreman what command they should use, and above a simple Procfile for the scenario:

Very simple file, I've a process called mond, wich executes "sudo mongod" and starts the mongodb database, You'll see in the console, something like that "mongod.1 | started with pid XXX", every log from mongod will appear in the console.

To start all this process type "foreman start", Now I've only one tab running all my development processes.

A Todo App written in backbone.js

2011-08-29T06:55:00.000-07:00

Hey Guys,

I'm back again :)

I the weekend I write a simple app based on the Backbone.js demo the Todo App, this app is very simple, and has only one model. In my first studies I'm tried to make this todo model related to an todo list, such as the 37Signals' application Tada List, here you have a main list, and you add your tasks inside this list. But I fail with that, I can't understand Backbone itself, and I'm trying to do JQuery things and Rails Things on the backbone, and the app is not what I'm trying to do. You can checkout the source code of this fail (but working) app here: https://github.com/fellix/todo-list

Well, I forget that app, and I passed to study more about the backbone, I take a look inside the router, written the backbone-galley in a rails app, and that give me more details about the backbone. With that visions I tried to write the todo-list app again, but for now, I using Rails 3.1.rc5 and coffeescript, I have no problems with coffeescript insted of JavaScript, and I don't know why many people hates coffeescript.

After that write the app comes up http://backbone-todos.heroku.com/ and you can checkout the source code at https://github.com/fellix/backbone-todos, I'm choice the haml-js for the views, I really love haml :), for the Rails 3.1 I used that gem (https://github.com/andrewtimberlake/ruby-hamljs) for render the haml-js template, and works like magic.

Going back to the app, the only view that was served by the rails is the home/index.html.haml, wich have only the div wich is used for render the templates, all of you can see is rendered for backbone.

That's all folks

Backbone.JS

2011-07-19T06:38:00.000-07:00

Faz muito tempo que não escrevo aqui no blog.
Ultimamente estou bem atarefado e tenho muitas coisas a escrever e publicar, porém me falta tempo para organizar as idéias e as por no blog.

Hoje vou falar de um assunto que está me tomando um certo tempo meu. Estou estudando Backbone.JS

WTF?

Backbone é um framework JavaScript para criação de Front-end RIA (Rich Internet Application), Novidade? Não.

O Que mais chamou a atenção no backbone, diante das 1239081238109238 opções que existem?

1) Suporte a Mobile.
2) Integrado com JQuery
3) Visual Clean
4) Focado em MVC
5) Usa RestFull

5 itens para ressaltar o por que do Backbone.

Desenvolvendo

O mais legal do Backbone é que ele é puro JavaScript, não existem tags geradas durante a execução, e seu CSS pode ser usado sem nenhum problema. E o principal o código gerado é o codigo escrito, usando tanto Inspect Element quanto um View Source não vão mostrar um código absurdo que somente seu navegador consegue ler. Nunca fui muito fã de aplicações RIA, justamente por que elas dificultam essa parte de inspeção dos elementos e foi justamente isso que me chamou a atenção no backbone.

Basicamente o Backbone é composto por Events, Models, Collections, Routers e Views.

Event: É um modulo que pode ser anexado em outros objetos. Ele é simplesmente composto dos metodos bind, unbind e trigger.

Model: É o núcleo da sua aplicação com Backbone, é nele que ficam as lógicas de persistencia, validação, e algum trabalho com a tela. Um model pode ser qualquer coisa, assim como no Rails seu model não precisa, necessariamente estar ligado a um base de dados. Um exemplo de um Model

O uso do window é usado somente para definir esse objeto como global para poder usar por exemplo new Album. Essa é uma das maiores classes do Backbone, vale a pena dar uma olhada na documentação

Collection: Não são nada mais do que uma coleção de modelos. Para definir é necessário passar o model que representa essa collection e também um URL que será usada para buscar e preencher a listagem.

Esse é outro objeto simples do backbone :)

Router: Router é responsavel por gerenciar as urls do backbone. e saber para qual callback redirecionar. as urls do backbone começam com um # ex: (#users/felix). Nem toda a aplicação precisa de um Router, mas se sua aplicação precisar de uma complexidade maior vai precisar sim :)

PS: Na versão 0.3 do backbone ele era chamado de Controller.
Reparem que na definição da rota eu não preciso definir o # antes da url, mas para executa-la nas views o link deve ser #collection/1/album/1 reparem que substitui os wildcards (:album_collection_id e :id) pelos ids que vou trabalhar, esse link com o # dispara o router do backbone que já deve ser previamente inicializado (new), e deve existir uma (uma e somente uma),chamada ao metodo Backbone.history.start() dessa forma o backbone inicia a leitura das URL.

View: Uma view para o backbone é algo renderizado na tela, baseado em tags, vc pode renderizar suas telas usando JavaScript, cada view é responsavel por gerenciar seus eventos. Existem um atributo chamado events, onde os eventos podem ser definidos como por exemplo para submter o form da propria view você teria uma sintaxe parecida com essa "submit form": "save", onde submit é o evento, form é selector do JQuery, e save é o callback que será executado quando o form for submetido. Simples não?

Exemplos

Sem mais o que falar vou por alguns links aqui.

http://addyosmani.com/resources/backbonegallery/index.php

Essa foi a aplicação base para fazer alguns estudos e me ajudou bastante a entender alguns conceitos sobre o backbone.

Reescrevi a mesma aplicação usando o Rails 3.1:

https://github.com/fellix/backbone-rails-gallery

Na wiki do Backbone tem muito mais exemplos não deixem de conferir, existe até um exemplo de Mobile :)

https://github.com/documentcloud/backbone/wiki/Tutorials%2C-blog-posts-and-example-sites

Nova fase

2011-05-01T17:50:00.000-07:00

Bah, falei que não ia usar mais o blogger, mas é muito melhor que minha própria ferramenta :P.

Desculpem ficar tanto tempo sem escrever, porém estava numa correria nos últimos tempos. Após 2 anos e 4 meses trabalhando na SeRHmática, saí para encaram um desafio novo, sempre gostei de trabalhar lá, mas senti que era hora de tentar algo novo diferente.

Sempre trabalhei como CLT, mas agora vou trabalhar como PJ e em Home Office, meu medo é de não me acostumar :P, amanhã (02/05/2011) é meu primeiro dia full time na Crafters, estou trabalhando já a um mês com eles em um projeto Ruby on Rails.

Me desejem sorte :)

Novo blog

2011-02-08T16:27:00.000-08:00

Galera escrevi meu proprio blog, e vou abadonar o blogger :), aos poucos claro, mas posts futuros somente no novo (temporário) endereço http://rollingwithcode.heroku.com/

JPA 2.0 Criteria Sucks

2011-01-10T09:38:00.000-08:00

I sometimes need to use the Criteria in JPA, I don't know why, but the create query method not accept order with asc and desc in the same query, the Criteria support it, but damn, it's very hard, I don't know who think this code

ParameterExpression age = qb.parameter(Integer.class);
Predicate condition = qb.gt(p.get(Person_.age), age);
c.where(condition);
TypedQuery q = em.createQuery(c); 
List result = q.setParameter(age, 20).getResultList();

is better than this one

String jpql = "select p from Person p where p.age > :age";
Query query = em.createQuery(jpql).setParameter("age", 20);
List result = query.getResultList();

I don't need to map my class into another object called metamodel, one change in a model results into two changes, the model and the metamodel. Go to hell with de metamodel, we don't want, and don't need it, I write my queries using JPQL and don't want to use the Criteria API. Why they don't use the hibernate style? The code below isn't better?

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.between("weight", minWeight, maxWeight) )
    .list();

Yes, I copy this codes from IBM and Hibernate:).

RSpec+Mongo+DatabaseCleaner

2011-01-09T09:32:00.000-08:00

Em portugues

Some times ago, I wrote about RSpec and MongoDB I was used the DatabaseCleaner 0.5.2, the version 0.6.0 was released some times ago, and I not tested it before, the changes are simple, the main change is the orm options need to be before the stategy option, see below the spec_helper.rb:

RSpec.configure do |config|
  config.before(:suite) do
    DatabaseCleaner.orm = :mongoid
    DatabaseCleaner.strategy = :truncation    
    DatabaseCleaner.clean_with(:truncation)
  end  
  config.before(:each) do  
    DatabaseCleaner.start
  end
  config.after(:each) do  
    DatabaseCleaner.clean
  end
end

Also changed the before option, now it's initialize the Cleaner, and the after option, clean the database

RSpec+Mongo+DatabaseCleaner

2011-01-09T09:23:00.000-08:00

A algum tempo atrás escrevi sobre RSpec e MongoDB a versão que usei o database cleaner na época era a 0.5.2, a algum tempo atraz saiu a versão 0.6.0, e eu ainda não havia testado, bom as alterações são simples, a principal é que o orm deve vir primeiro, veja abaixo como ficaria o spec_helper.rb

RSpec.configure do |config|
  config.before(:suite) do
    DatabaseCleaner.orm = :mongoid
    DatabaseCleaner.strategy = :truncation    
    DatabaseCleaner.clean_with(:truncation)
  end  
  config.before(:each) do  
    DatabaseCleaner.start
  end
  config.after(:each) do  
    DatabaseCleaner.clean
  end
end

também foi alterado para o before, iniciar o Cleaner, e o after para limpar. :D

Ruby on Rails + JasperReports (IReport)

2010-12-28T04:47:00.000-08:00

Atualmente aqui na Serhmática, usávamos um sistema interno, uma aplicação "Cobaia" feita em Swing para gerencia de projetos, estávamos a algum tempo estudando o desenvolvimento de uma nova ferramenta WEB, onde nossos clientes pudessem acessar, diminuindo o fluxo de email, e tornando o contato com o cliente mais transparente. Como estamos com muito tempo de sobra, não conseguimos progredir com a aplicação, e procuramos uma solução que pudesse nos atender, eis que encontramos o Redmine, uma aplicação escrita em Ruby on Rails, nossa intenção inicial, era rodar no Glassfish que já tinhamos configurado, porém houve inconsistências, BUGS não explicados pela internet, e partimos a rodar via Mongrel mesmo.

Testamos e gostamos da ferramenta, ainda não está pública para os clientes, mas aos poucos vamos liberando, surgiu um outro problema, precisávamos de alguns relatórios no nosso estilo, que pudesse ser encaminhado aos clientes, a primeira coisa que pensei foi FODEU.

Pesquisei na net e cheguei até um blog brazuca, que tinha um projeto parecido com o que eu queria, testei os códigos desse cara, infelizmente ele não lista os jars que vc precisa, mas vou listar aqui:

commons-beanutils
commons-collections
commons-digester
commons-logging
commons-logging-api
iText
jasperreports
postgresql

e tive o primeiro sucesso, e veio o primeiro problema, precisava parametrizar as buscas, não como no modelo do cara, dai resolvi fazer diferente:

1) Criar no relatorio_controller uma action e mapeei ela no routes.rb
2) Criei a tela com form_tag e adicionei os parametros
3) no retorno da action fiz a busca e mandei pro relatório.

Eis que vem o primeiro erro, o JasperReports não conseguiu processar o modelo do Ruby.
Matutei uma solução e encontrei, criei um projeto bem simples, coloquei uma classe la dentro, e adicionei os campos, no IReport criei o relatório com base naqueles campos. A classe ficou mais ou menos como a classe abaixo:

public class Relatorio{
  private Integer issue_id;
  private String issue_subject;
  private String issue_description;
}

criei assim mesmo fora do padrão com os underlines (_) para ser mais facil pro ruby reconhecer.
depois da busca efetuada, percorri o resultado e fui criando novos objetos desse relatorio, passei esse objeto para o model Relatorio e no final converti o Ruby Array em um ArrayList e depois em um JRBeanCollection

@dataSource = JRBeanCollectionDataSource.new(ArrayList.new(dados))

editei tbm o metodo to_pdf e ficou assim:

def to_pdf
    fill = JasperFillManager.fill_report(@modelo, @params, @dataSource)
    pdf = JasperExportManager.export_report_to_pdf(fill)
    return String.from_java_bytes(pdf)
end

e pronto, agora estou com o Redmine rodando no mongrel e gerando relatório em PDF com o JasperReports.

Em tempo: Criei um jasper.rb na pasta config/initializers, ele carrega as libs ao invés de deixar no model.

Tbm alterei os observers e os fiz rodar em um Thread a demora do servidor de email pra responder causava lentidão no sistema, por exemplo o MessageOberver

class MessageObserver < ActiveRecord::Observer
  def after_create(message)
    t = java.lang.Thread.new do
      Mailer.deliver_message_posted(message) if Setting.notified_events.include
    end
    t.start
  end
end

Espero que isso seja util pra mais alguém, qualquer dúvida comenta ai que vejo se posso ajudar.

Days of week in ruby

2010-12-15T16:15:00.000-08:00

Em português

I don't know why, nobody need it, I searched at the web, and I'm not found a solution for this, by the way, I implement my own solution.

You can see some explain about the method here (in Pt-Br): http://www.arlindo-correia.com/140101.html
But, I converted the javascript code at http://www.profcardy.com/calculadoras/aplicativos.php?calc=4 to ruby

the result is this monkey patch

class Time
  DAYS_OF_WEEK = [
    :saturday, :sunday, :monday, :tuesday, :wednesday, :thursday, :friday
  ]
  def day_of_week
    day = self.day
    month = self.month
    year = self.year
    if month == 1
      month = 13
      year -= 1
    end
    if month == 2
      month = 14
      year -= 1
    end
    phase1 = ((month + 1)*3)/5
    phase2 = (year/4)
    phase3 = (year/100)
    phase4 = (year/400)
    phase5 = day + (month*2)+phase1+year+phase2-phase3+phase4+2
    phase6 = phase5/7
    result = phase5-(phase6*7)
    DAYS_OF_WEEK[result]
  end
end

and some result by irb (I've used the rails console)

irb(main):001:0> t = Time.now
=> Wed Dec 15 22:05:00 -0200 2010
irb(main):002:0> t.day_of_week
=> :wednesday
irb(main):003:0> t.prev_month.day_of_week
=> :monday

If somebody know another way to do it, I'm listening

Dias da Semana no Ruby

2010-12-15T16:08:00.000-08:00

Não sei por que ninguem nunca precisou isso no ruby, sei la, procurei na net e não encontrei nada resolvi implementar minha propria solução.

A documentação teorica está aqui: http://www.arlindo-correia.com/140101.html
Porém pra fazer a conversão, converti o codigo desse site http://www.profcardy.com/calculadoras/aplicativos.php?calc=4 do javascript para o ruby

o resultado foi esse monkey patch

class Time
  DAYS_OF_WEEK = [
    :saturday, :sunday, :monday, :tuesday, :wednesday, :thursday, :friday
  ]
  def day_of_week
    day = self.day
    month = self.month
    year = self.year
    if month == 1
      month = 13
      year -= 1
    end
    if month == 2
      month = 14
      year -= 1
    end
    phase1 = ((month + 1)*3)/5
    phase2 = (year/4)
    phase3 = (year/100)
    phase4 = (year/400)
    phase5 = day + (month*2)+phase1+year+phase2-phase3+phase4+2
    phase6 = phase5/7
    result = phase5-(phase6*7)
    DAYS_OF_WEEK[result]
  end
end

E os testes usando irb (na verdade usei o console do rails)

irb(main):001:0> t = Time.now
=> Wed Dec 15 22:05:00 -0200 2010
irb(main):002:0> t.day_of_week
=> :wednesday
irb(main):003:0> t.prev_month.day_of_week
=> :monday

Se alguem souber como recuperar o dia da semana sem o path me avisa ehhee.

Modelos sem tabelas no rails

2010-12-08T14:01:00.000-08:00

Bah, esse me surgiu esses tempos, e resolvi fazer alguns testes, eu armazeno um objeto em uma sessão com o rails, mas eu não tinha intenção de armazenar essa bagaça na base, somente em memória. sem ideias fui eu pela internet buscar como fazer isso. O Rails 3 modularizou boa parte do rails, um refactoring grande, mas que facilitou muita coisa, como o teste abaixo, por exemplo:

class Person
  attr_accessor :name, :age
end

Ta tio, e se quiser usar as validações e outras coisas do rails? vou ter que fazer tudo no braço? Bom é claro que não né, que puta perca de tempo isso. Veja a adaptação abaixo:

class Person
  include ActiveModel::Validations
  include ActiveModel::Conversion
  extend ActiveModel::Naming

  attr_accessor :name, :age
  validates :name, :age, :presence => true

  def initialize(attributes = {})
    attributes.each do |name, value|
      send("#{name}=", value)
    end
  end  
  
  def persisted?
    false
  end
end

vejam só que maravilha, agora vc pode fazer coisas como essas (irb):

p = Person.new
=> #
p.valid?
=> false
p.errors
=> #["translation missing: br, activemodel, errors, models, person, attributes, age, blank"], :name=>["translation missing: br, activemodel, errors, models, person, attributes, name, blank"]}>

Ooops, falta as traduções, mas isso é dever de casa né ashudahushud.

Formulas Matemáticas Em Java

2010-11-18T02:33:00.000-08:00

Quem nunca precisou usar alguma formula matemática em Java, para efetuar alguma operação?

Existem alguns casos que o usuário quer definir a formula do calculo. Muitas vezes isso é uma comodidade para ele, e um PARTO para os desenvolvedores, algumas metodologias ou bibliotecas resolvem o problema, porém você tem que implementar algo, sempre tem algum ajuste. Precisei usar o Metodo Price em um calculo financeiro, a formula não é complexa, mas como toda a formula matemática, deve se ter cuidado com os parênteses. Eu pensei em fazer algo mais braçal, mas como um bom preguiçoso, resolvi gastar um certo tempo pesquisando algumas maneiras de fazer isso, eis que me surge uma luz no fim do túnel, o Bean Scripting Framework. Linguagens de script são mais flexíveis nesse aspecto que em Java, muitas vezes temos que fazer em alguns casos contornos maiores, como usamos Java 6 para desenvolver, que tem suporte ao ScriptEngine, tudo flui mais fácil, se você usa alguma versão mais antiga, por favor faça um upgrade urgente, quem está perdendo é você.

PS: As bibliotecas são referenciadas via maven, se for usar ANT ou qualquer outra coisa, tem que procurar no Google.

vamos precisar de duas simples bibliotecas o projeto o Bean Scripting Framework (BSF -> bsf:bsf) e o groovy (org.codehaus.groovy:groovy) (você pode usar Jython, JRuby, e qualquer outra coisa que queira), vou usar uma formula simples inventada por mim: x ** 2 + 10

auhsduhahsduas, chega a ser ridículo, mas depois muda isso ai pra testar (o operador ** no groovy representa potenciação)

Olha a trabalheira:

String formula = "x ** 2 + 10";
BSFManager manager = new BSFManager();
manager.declareBean("x", "10", Integer.class);
Double result = (Double) manager.eval("groovy", "myScript.groovy", 0, 0, formula);

Eu fiz um cast pra Double, mas o retorno é um object, pode retornar qualquer coisa.
Mas fácil que isso só dois disso heheh.

Haml+Rails

2010-11-09T12:41:00.000-08:00

Haml é uma linguagem de marcação, para renderizar templates HTML, baseada em tags e identação. Sempre gostei muito de usar o HAML nas minhas aplicações Rails 2, pela simplicidade e facilidade na criação. Você se acostuma a identar ao invés de procurar aonde a tag deve ser fechada. O Rails 3 foi modularizado para facilitar a customização. Porém a gem haml, responsável por renderizar os arquivos HAML, não possui generators embutidos para o Rails, procurando na internet encontrei o projeto rails3_haml_scaffold_generator que faz exatamente isso, mas vc precisa executar alguns passos, e eu odeio coisas repetitivas, a primeira coisa que pensei foi procurar se havia alguma gem parecida, e não encontrei.

Resolvi arregaçar as mangas, e fiz minha primeira gem, no caso eu simplesmente movi para o diretório os arquivos como se fossem um gem, e ajustei os diretórios com a ajuda do Jeweller.

O uso dessa gem é bem simples, ela nem tem reação com a gem haml, pois ela consiste somente nos generators.

Adicione ao seu Gemfile as seguintes linhas

gem haml
gem haml_rails

use o bundle install ou uso o gem install para instala-las.

depois só executar o comando

rails g haml_rails:install

ele vai editar seu application.rb e adicionar o haml como seu template engine. vc pode apagar caso prefira usar o ERB.

Por enquanto é isso..

Rails 3, RSpec 2, Devise a MongoDB

2010-10-17T11:17:00.000-07:00

Estive estudando o Rails 3 (Atualmente 3.0.1 para o rails), e também estudando um pouco de NoSQL, com o MongoDB, ainda pretendo me dedicar um pouco para aprender sobre o Redis, mas por enquanto estou vendo o Rails. Gosto de usar para autenticação o Devise, um projeto brasileiro, que se tornou bem famoso pelo mundo Rails. Para ORM gostei do Mongoid, e ainda mais pelo devise ter suporte ao mongoid ao invez do ActiveRecord.

Iniciando

Sobre o mongoid não há muito o que falar, a documentação presente no site é completa, e funciona muito bem, vale lembrar que arquitetura de um banco relacional é bem diferente de um NoSQL, e algumas definições já padrão na nossa cabeça devem ser desfeitas.

O RSpec-Rails vem configurado para rodar sobre o ActiveRecord e quando vc executar um rails g rspec:install ira gerar toda a estrutura padrão do rspec, incluindo a pasta spec que contem os testes. Primeiramente vamos editar o arquivo spec/spec_helper.rb

RSpec.configure do |config|
  require 'database_cleaner'
  
  config.before(:suite) do
    DatabaseCleaner.strategy = :truncation
    DatabaseCleaner.orm = "mongoid"
  end

  config.before(:each) do
    DatabaseCleaner.clean
  end
  config.mock_with :rspec
  config.include Devise::TestHelpers, :type => :controller # Essa linha adiciona os helpers do Devise para o RSpec.
end

A adição da gem DatabaseCleaner (que deve estar declarada no Gemfile), serve para limpar os resultados dos testes apos a execução, como podem reparar o uso de fixtures é desabilidado para o Mongo, somente para o ActiveRecord, sem o uso de fixtures os testes são mantidos na base, o que não é interessante.

Testando os controllers

Criei um modelo simples com o devise, apesar da documentação do devise indicar a criação de um modelo Admin para esses casos, preferia adotar o uso de um flag para poder indicar se o usuário é um administrador, acho isso um tanto mais simples.
Adicionei também no application_controller.rb um metodo filtro que indica se o usuário é um adminsitrador

protected
  def admin_user!    
    if authenticate_user!      
      unless current_user.admin        
        flash[:warning] = "Acesso Negado"
        redirect_to root_url
      end
    end
  end

reparem que usei o filtro authenticated_user! que é do devise pra indicar que o usuário está logado no sistema.
meu controller admin_controller.rb

class AdminController < ApplicationController
  before_filter :admin_user!
  
  def index
  end

end

é um controller bem simples, mas para garantirmos a segurança do aplicativo, e se algum dia nosso filtro precisar ser ajustado precisamos garantir que o acesso a esse controller seja restrito sempre, e quem alterar deve ter noção da quebra do teste.Em alguns dos meus testes, normalmente em fixtures, eu pego um hash que representa o codigo BCrypt da senha (padrão do Devise), mas como aqui no mongo não tem fixutes, parti pra outro ponto.

require 'spec_helper'

describe AdminController do
    
  describe "GET 'index'" do    
    def do_action_with_user(admin)
      @user = User.create!(:name => "Test", :email => "test@test.com", 
        :password => "testet",
        :password_confirmation => "testet",
        :admin => admin)        
      sign_in @user
      get 'index'
    end
    #1
    it "should not be successful when no user was logged in" do
      get 'index'
      flash[:alert].should_not be_nil
      response.should_not be_success
    end
    #2
    it "should not be successful when no admin user was logged in" do
      do_action_with_user(false)      
      flash[:warning].should_not be_nil      
      response.should_not be_success
    end
    #3
    it "should be successful when admin user was logged in" do
      do_action_with_user(true)
      response.should be_success
    end
  end

end

bem simples, um metodo dry pra fazer o registro do usuario e usar o metodo auxiliar do devise para o login (sign_in):

o teste 1 é um teste para acesso sem login, no caso uma chamada a action index do controller admin sem um usuário logado.
teste 2 teste para um usuário que não é administrador, repare que testo se o flash esta preenchido
teste 3 testa a ação de sucesso, no caso o acesso de um usuário administrador

Inicialmente esse teste se fez suficiente para dizer que agora a classe está segura.

Outras notas

Tive alguns problemas no começo do uso do RSpec 2 em views, e vou listar aqui alguns deles:

assign :name, "Teste"

ao invez de

assigns[:name] = "Teste"

Outra mudança é que em views você não deve mais usar o response, mas usar o rendered.Também deixou de existir o metodo have_tag, para verificar o conteudo de uma tag, veja abaixo:

#RSpec 3
assert_select('p', "Teste")
#RSpec 2
response.have_tag 'p', "Teste"

Espero que isso seja util pra mais alguem, pelo menos eu não vou mais esquecer :D

Software é como uma obra de arte

2010-09-20T07:40:00.000-07:00

Para quem vê, pode ser estranho, bonito, sem sentido, mas para quem é da área tem que ser maravilhoso.

O Software em si, deve ter as funcionalidades certas, ser bem definido, para o usuário também acha-lo bonito e prático. Mas meu foco aqui não é o cliente e sim os desenvolvedores. Seu software deve ser referencia, considerado uma obra de arte para outros desenvolvedores, deve ser prazeroso olha-lo e não um martirio, a manutenção deve ser facil, e os retoques simples.

Muitas vezes uma decisão errada no começo pode levar a um design de código feio, ou a alguma dificildade em adicionar novas funcionalidades, ao ver isso, não devemos usar o algoritmo do avestruz, e sim, gastarmos algum tempo para corrigir isso, melhor esse treco de codigo que pode ser uma futura pedra no seu caminho. Costumo em alguns dias revisar códigos antigos, feitos no inicio de um projeto afim de aperfeiçoá-lo e torná-lo melhor, mais bonito e mais prático, e algo que as vezes leva algum tempo, mas normalmente são alterações de minutos, e que podem resultar em um ganho grande de leitura de codigo em revisões futuras.

Afinal, somos criadores, e todo o criador precisa fazer alguns ajustes na sua cria, afim de torna-la melhor sempre.

Deu Certo? Deixa! Funcionou? Não Mexa!

2010-08-30T12:08:00.000-07:00

Essa piadinha aí, muito engraçada as vezes, pode não caber na empresa onde trabalha.

Algumas vezes em alguns projetos os prazos apertados nos forçam a escrever certos franksteins, que não são bonitos mas funcionam, "tampam o buraco", na maioria das vezes, o que acontece é que esse frankstein se torna uma mumia de tantos remendos e concertos. Quando seu código chegou ao ponto do titulo, onde cada alteração é muito perigosa, ligue o sinal vermelho, chegou a hora de parar o que está fazendo e rever essa bagaça.

O tempo de análise do código não deve ser maior que a implementação da alteração. Se você leva mais tempo para entender o que seus metodos fazem, é sinal que seu código está pouco legivel, e precisa ser revisto, muitas vezes é melhor perder certo tempo, algumas vezes diversas horas para refazer esse código, a melhoria para o cliente não é visivel, ele sequer vai saber que você mecheu nisso, deve funcionar igual, porém mais facil de ser avaliado e analisado, consequentemente mais facil de altera-lo.

Acreditar que o sistema será imutavel e dar um tiro no proprio pé, ou no pé dos companheiros, tenha em mente que a flexibilidade e legibilidade devem ser a base do sistema, e deve ser facil para todos alterar cada parte, esteja ciente que nem sempre será você quem vai alterar esse trecho.

Rails 3 is out

2010-08-30T05:51:00.001-07:00

Não deu nem tempo de postar sobre meus testes com o Rails 3 RC e a versão final está disponivel :)

http://akitaonrails.com/2010/08/29/rails-3-0-final-acaba-de-ser-lancado

JavaME, Android e JavaFX

2010-08-30T03:46:00.000-07:00

A dois anos atrás, JavaME era uninimidade no desenvolvimento para celular, além de rodar na maioria dos dispositivos era simples e facil de desenvolver usando ele. Android apenas engatinhava, e a cada nova versão, devia se reaprender a desenvolver, pois muita coisa mudava. Os fãs de JavaME diziam que Android não seria ameaça ao JavaME, pois ainda faltava anos de estrada para se aprimorar, além de ser um sistema operacional, seria necessário reinstalar o novo sistema no celular.
Nesses dois anos, JavaME não mudou NADA, continuou a mesma coisa, ficou estagnado no tempo, sem melhorias, ou algo que acompanhasse a evolução do Java, normalmente era aquela mensagem: "Muitas fabricantes usam, como vamos pedir pra eles reimplementarem Java para seus dispositivos?", a resposta, seria algo como um, use a versão que quiser. Enfim, enquanto o JavaME ficava la assistindo TV, o Android cresceu, sai dos dispositivos moveis, chegou aos netbooks, e hoje, tem muito mais desenvolvimento e melhorias frequentes que o JavaME, a diferença, é que surgiram celulares diferentes da epoca da criação do JavaME, como o iPhone, que possui seu proprio SDK para desenvolvimento.
Aí vem a pergunta dos mais fanaticos por Java (Aqueles que acham que tudo em Java é melhor que o resto =D), e o JavaFX? Pra mim JavaFX é um tiro no proprio pé, foi no da Sun, e será no da Oracle. Existem tecnologias melhores, e não estão estagnadas como o JavaME do caso assim, como o Flex e o Silverligth, o JavaFX tem que evoluir muito para competir com essas tecnologias. Ainda há quem diga, que o Swing, JavaME e JSF vão ser substituidos pelo JavaFX, mas eu não creio que o JavaFX viverá para tanto. JavaFX apenas engatinha enquanto seus concorrentes voam...

PS: Prometo tentar escrever mais seguido (ou não) =)

Alterar o classpath em tempo de execução

2010-07-14T04:03:00.000-07:00

Muito comum essa dúvida, porém nem tão pratica :D.

Para ferramentas baseadas em plugins o ideal é usar OSGi mesmo, que funciona muito bem.

Mas existem casos em que precisamos de um determinado jar que não está no classpath da aplicação seja adicionado de acordo com as vontades do usuário.
Existe um metodo bem simples, usando reflection que permite que isso seja feito.

File f = new File("ABSOLUTE FILE PATH");
URL url = f.toURI().toURL();
URLClassLoader classLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
method.invoke(classLoader, url);

o metodo toURL dentro da classe file está deprecated, então usamos o toURI e depois toURL, lembrando que para criar o arquivo é necessário o caminho completo do Jar.

usando reflection pegamos o metodo protegido "addURL" dentro do URLClassLoader, e simplesmente o invocamos :D

Bem simples e funcional.

Testes Unitários e Metodologias Agéis

2010-07-12T12:40:00.000-07:00

Bah, desculpem por não postar nada, sabe como é brasileiro em Copa do Mundo né :). Não pude deixar o fanatismo de lado.

Ultimamente estive pesquisando e lendo muito sobre testes unitários e metodologias agéis de desenvolvimento e uma parte que eu gosto muito são os testes. Gosto muito de criar testes fazer refactoring dos meus codigos sempre visando melhora-los, pois estamos sempre aprendendo e algumas coisas antigas ficam com brechas ou códigos horriveis. Porém, se existe algo chato, é criar testes, apesar de gostar existem coisas que chegam a ser ridiculas de serem testadas. e em linguagens como Java, o esquema do Antes crie o teste, depois crie o codigo não funciona, pois se o metodo não existir na classe vc nem consegue compilar.

Mas a minha decepção não é nem com os testes, que sim, são chatos de serem feitos, mas eu acho algo interessante. O que me deixou meio abismado, foi uma certa metodologia agil, o eXtreming Programming (XP). Lendo sobre o XP, parecia tudo muito bonito, muito bacana, mas aí veio um tal de Pair Programming. Puts eu queria saber quem foi o FDP que acha isso legal? Não existe nada mais chato que passar 8 horas do dia assistindo alguem programando, sim concordo nos louros dessa metodologia, é visível que alguem de fora encherga os seus erros de uma maneira mais facil, mas ninguem pensa no coitado que fica sentado ali do lado? Mesmo que haja revezamento no PC, quem não está programando, vai estar bocejando.

Dai veio o motivo de usar tal metodo...
A pressão do par! Não basta você estar o dia todo na empresa, e não podem nem olhar seus e-mails? Não vai poder se distrair 5 minutos? isso é coisa de Gerente Capataz. Numa profissão maçante como a nossa, acredito que um pouco de descontração (sem esquecer do trabalho é lógico), é fundamental. Acredito que na resolução de um problema, duas cabeças pensam melhor que uma. Mas agora para coisas básicas, acredito que cada um pode se virar, penso no Pair Programming diferente. Acredito que cada uma na sua máquina, em busca do mesmo problema, ou usando papel discutindo o problema, normalmente é mais vantajoso que passar o dia todo assistindo o outro trabalhar.

Não sou contra o Pair Programming, mas vejo mas como uma solução de problemas, por exemplo: Temos um problema vamos discutir e resolve-lo juntos. Após o problema resolvido cada uma volta as suas tarefas normais. Pelo que entendi, o par deve ficar o tempo todo do lado lendo o que o outro escreve e corrigindo os erros.

Só um desabafo.
Tem muito gente que não percebe como funciona para empresas como Google, Microsoft. Ainda acham que funcionários são recursos...

Especialistas dizem que faltam vagas na área de TI

2010-05-31T04:10:00.000-07:00

Quem nunca ouviu falar disso? Jornais, noticiários, todo mundos gosta de enaltecer o excesso de vagas no mercado de TI, até comentam de empresas que ficam anos com vagas abertas e não conseguem preenche-las.
Existem vários tópicos no GUJ, comentando sobre essas afirmações feitas por profissionais jornalistas, não profissionais da área de TI. Partindo do suposto que estatisticamente a quantidade de vagas em aberto x o número de candidatos e o tempo que elas permanecem em aberto significam que sobram vagas, correto? Bom, não é bem esse o caminho.
Nem sempre quantidade quer dizer qualidade, o pessoal não está ciente de como é difícil achar boas vagas, e ninguém sai em busca de empresas no estilo Google de ser. Muitos só querem trabalhar ter seu dinheiro e aprender coisas novas.
Sua empresa não acha profissionais para contratar? Bom, existem algumas opções que sua empresa deve analisar:

Sua empresa sabe o que precisa, qual cargo pretende contratar?
Sabe a média salarial de profissionais desse cargo e com os conhecimentos pedidos?

Somente essas duas perguntas podem responder por que você não acha um profissional nem que seja medíocre para contratar. Por quê? Por que na maioria dos casos o que vemos são vagas em busca de mão de obra qualificada, com baixo salário e que de preferência possa ser ninja e fazer tudo o que for pedido. Já cheguei a ver vagas onde os requisitos no mínimo eram pra sênior , mas a vaga era pra um ESTÁGIARIO, leu bem? Seria a mesma coisa que pedir para um estagiário do escritório de contabilidade saber fazer metade da movimentação contábil das empresas sem ajuda, isso é completamente ridículo, e o salário é claro incompatível com os conhecimentos.
Ai vale a ressalva de que muitas dessas vagas em aberto são exclusivas, e garanto que removendo essa massa de vagas, teríamos ai um mercado equilibrado, sem esse excesso de vagas, que vemos serem veiculados por ai.
É muito simples avaliar que a anos sobram inúmeras vagas em TI, mais ai que os cegos não enxergam, sobram vagas, ou as empresas não sabem contratar profissionais?

Pensei bem se publicava ou não essa bagaça, mas que sabe, ta ai :)

Ubuntu 10.04 e a placa NVIDIA

2010-05-06T12:58:00.000-07:00

ba, sei que isso não tem a ver com programação, mas isso foi um acontecimento bacana pra postar aqui.

dia 29 saiu o Ubuntu 10.04, e eu facero, segunda feira fui tentar instalar, ver como ficava o ubuntu, e me assustei com o que vi, a imagem completamente distorcida, era tudo meio nas escura pra selecionar, realmente uma bosta, meu notebok é um HP DV6704nr. E procurava na net não achei uma solução para utilizar, resumindo mantive a versão 9.10, hoje meu colega o Jean (Zize), me deu uma ajuda (leia-se configurou) o ubuntu 10.04 na maquina.

A instalação ocorre meio na obcuridade, se vc for em experimentar ubuntu, e alterar a resolução você ate consegue ver o sistema direito, em alguns casos aparece uma tela preta e uma janela de aviso, se aparecer isso aperte enter, e uma tela com algumas opções visivel pela metade aparecerá, você vai ate a ultima opção, aperta pra baixo umas 10x, presciona a barra de espaço para selecionar (lembrando que a seleção deve estar no checkbox não na escrita), e de dois tabs e um enter, o sistema iniciara com os drivers genericos sem problema, e vc prossegue com a instalação.

Após instalado, o sistema deverá apresenta a mesma tela com o aviso, que vc não consegue ler, tem que repetir o procedimento para o sistema iniciar.
Dentro do sistema o primeiro passo e ajustar os repositorios, está com um problema no hash MD5 de alguns que vem previamente instalados, ou seja o sistema não vai identificar os drivers:

Sistema -> Administração -> Canais de Software

Desmarque a opção do multiverse e coloque a opção baixar de para o servidor principal. Atualize os indices, volte aos canais de Software, e marque o multiverse e coloque para baixar de Servidor no(a) Brasil. Atualize novamente os indices, e agora vc tem os drivers disponiveis para instalar. Pode ser usado tanto os Drivers de Hardware no menu Administração ou na Central de Programas. Baixando e instalando o driver o Ubuntu vai funcionar tranquilamente.

Agora fico na duvida, por que que o pessoal do ubuntu fez esse favor para nós?

To com ubuntu 10.04, e aparentemente ta muito bacana, e o boot ta realmente rapido :), vamo que vamo

Glassfish v3 EJB e Standalone Client

2010-04-23T03:27:00.000-07:00

Não sei se muita gente usa isso, mas eu uso, um client swing, para um modulo EJB, recentemente, saiu a versão V3 do glassfish, e lá fui eu tentar comunicar com o container EJB, até a versão v2 as bibliotecas necessarias eram o JavaEE 5, appserv-rt, appserv-deployment, appserv-admin e o appserver-ext, isso devia tar entorno de uns 20MB de bibliotecas.

Seguindo ao FAQ do Glassfish eu devia adicionar somente o GF-CLIENT no classpath da applicação, um jarzinho de alguns KB, e adivinha, não funcinou, depois de uma extensiva busca não encontrei solução e cheguei a conclusão que, NÃO ACREDITE NO FAQ DO CLASSFISH. Além desse tal de gf-client, eles aconselham vc a usar o construtor sem argumentos da classe InitialContext, se vc quiser conectar SOMENTE EM LOCALHOST use o construtor sem argumetos.

Criei um projeto, adicionei todos os jars do GLASSFISHV3_HOME/glassfish/modules, a conexão funcionou 100%, agora era ver quais jars iriam manter minha conexão ativa, e fui removendo 1 a 1 os jars e testando, chegando finalmente a 6MB de jars (diminui bastante comparado com as versões anteriores), que devem estar no seu classpath, listados abaixo

auto-depends

common-util

config-api

config

config-types

deployment-common

ejb.security

ejb-container

glassfish-naming

glassfish-api

glassfish-corba-orb

glassfish-corba-omgapi

glassfish-corba-orbgeneric

glassfish-corba-codegen

glassfish-corba-newtimer

glassfish-corba-csiv2-idl

glassfish-corba-asm

gmbal

hk2-core

internal-api

javax.resource

java.ejb

kernel

management-api

orb-connector

orb-iiop

security

tiger-types-osgi

E nenhum dos gf-QUALQUER_COISA é necessario, essa aplicação está em produção desse modo. Alguns desses jars são encontrados em repositorios maven como tiger-types-osgi, eu optei por adicionar a maioria no repositorio local e esses mesmo para não ter problema.

RJS X Alert Com quebra de linha

2010-03-22T16:31:00.000-07:00

Mais uma poderosa batalha a ser travada, ahauhhuauha, estou cá eu com meus botões estudando rails, e resolvo por na mensagem de alert de erro os erros que ocorreram quando o objeto foi salvo meu snipet do rjs é algo semelhante a isso (Rails 2.3.4 e JQuery)

update.rjs


if flash[:error]
  page << "alert('#{flash[:error]}')"

Quando no controller havia uma única mensagem (Erro ao atualizar dados), esse snipet funcionava muito bem, muitos vão dizer que é mais facil usar so page.alert, sim é mais facil, enfim, o código tava assim e pronto ;)

Qual a solução encontrata para mostrar os erros? Bom percorrer o array de erros e mostrar cada um em uma linha não é? Coisa facil fui lá eu

controller.rb


def update
  #Preenche o objeto
  if @objeto.save
    #Não interessa
  else
   msg = "Erro ao atualizar dados \n"
   @objeto.errors.full_messages.each do |error|
    msg += "#{error.to_s}\n"
   end
   flash[:error] = msg
   respond_to
end

Muito simples né, e adivinha que me apareceu no alert?

"Erro ao atualizar dados \n Data não pode ser vazio\n"

sim os "\n" apareceram no alert se mudar para o
aparece no meio o
, eu tava quase querendo joga pela janela o PC, eis que eu resolvo recorrer ao nosso grande oraculo e encontrei um post de um caboclo falando a solução, pois ele passou por esse mesmo problema, e se vcs olharem o post do blog foi la em 2007 :(, só fazem 3 anos ahauuhauhah, resumindo, o que deve ser feito é criar um metodo na classe helper

helper.rb


def get_alert_error_message
  msg = "Erro ao atualizar dados \n"
   @objeto.errors.full_messages.each do |error|
    msg += "#{error.to_s}\n"
   end
  return msg
end

Reparem o código é exatamente igual

update.rjs


if @error
  page.alert "#{get_alert_error_message}"
end

E acreditem, exatamente o mesmo código, funcionou da forma que eu queria :), pra quem não consegue imaginar, a variavel @error foi criada para indicar quando ocorreu um erro no RJS, para imprimir esse alerta só se ocorreu um erro.

PS: Esse post além de compartilhar essa informação, é pra eu me lembrar futuramente disso ai.

IReport 3.7.X - A Saga

2010-03-15T10:18:00.000-07:00

Num sei vcs, mas tivemos diversos problemas com as versões do ireport pós 3.0, EJBQL Connection não funcionava, e ninguem sabia como resolver, cheguei a cirar 2 threads no Forum do JasperForge e ambas sem resposta, no final, ficamos com o IReport 3.0, a versão funcionava bem, apesar da interface ser meio bugada (algumas janelas eram fechadas e sumiam misteriosamente).

Sempre gostamos de ter nossas bibliotecas atualizadas, saiu um novo release lá estamos nós atualizando, e resolvemos testar as novas versões do IReport, porém nenhuma delas funcionava com EJB Connection, e existia um maldito EJBCascadingStyle, que a única coisa que pesquisando encontrei, foi referencia errada da versão do Hibernate. E eu atualizando os jar no diretorio ext no IReport e o erro persistia, então navegando encontrei uma solução, aparentemente, era copiar os jars principais do meu projeto no diretorio IREPORT_HOME/plataform9/lib

Realmente conectou usando EJB Connection, porém uma lesma ganharia na velocidade, o IReport ficou intrabalhavel, não conseguia editar um jasper qualquer quem diria criar um novo. Abandonamos e voltamos para a versão 3.0.

Buscando agora encontrei um topico realmente interessante, e esse sim fez o IReport funcionar.
Resumindo oq vc precisa é ir ao diretorio IREPORT_HOME/ireport/modules/ext

e REMOVER as libs ehcache, hibernate3, hibernate-annotations, hibernate-commons-annotations e jpa

e adicionar esses jar do seu projeto :D, assim funciona, agora encontrei um NullPointer na hora de editar a query, quem sabe até amanha eu consiga usar essa nova versão :P

O conto do merge, persist e do No Transaction

2010-02-09T01:34:00.000-08:00

Era uma vez...

Ehehhe, brincadeiras a parte, esses tempos tive um pequeno problema com uma certa demora usando JPA em um modulo EJB.

Tive de fazer a rotina de leitura de um arquivo texto e importar os registros para o sistema. até ai sem problemas, fiz a rotina e ela rodava em menos de 5s e importava todos os registros. Porém os registros que vinham no arquivo não atendiam a modelagem do sistema, ou seja, teria que inserir nas outras tabelas caso não existisse.

feita as Querys para encontrar o registro, e caso não existisse criar um novo, do nada ele demorou aproximadamento 6hrs e ao final la pela 1h30min da manhã uma execessão de No Transaction Active foi lançada em um flush no Entity Manager.

Lá fui eu aplicar algums caches de memoria para diminuir as consultas ao banco e os salvamentos. resolvemos mudar alguns merges para persist pois seguindo o que o pessoal fala, o persist é somente para objetos novos e é muito mais rapido.

Pois é não foi. Os objetos usando persist se tornaram pesados, e o procedimento ficou pesado, interrompido em 30min de execução tendo percorrido somente 200 registros (o arquivo possuia 30k). Removi o persist e deixei tudo como merge, mais uma vez uma No Transaction lá pelo registro 3mil é lançada. mais por que existe transação até o 2999. Eis que me dizem, põe um clear no começo do loop.

Galera, nunca vi o treco ir tão rápido ehhehe. Todo o gargalo de processamento se foi e o procedimento rodou em 5min.

Pra quem já teve esse problema não esqueça, o clear é muito importante :)

Aproveitando que estou falando sobre JPA e EJB...
Estavamos também com um problema ao salvar (merge) alguns objetos, a performance muito baixa, levava quase 2min para salvar o objeto, isso pos a chamada do em.merge.

Fiz varios testes, inclusive usando o clear, porém não deu em nada, resolvi arriscar, o problema estava nos objetos que eram atualizados e vinham do cliente, ou seja, estavam foram do contexto do EJB e do entity manager. Não sei se isso é gambiarra ou não, mas a performance melhorou drasticamente caindo para 2s.

primeiro passo eu recupero o objeto usando o em.find.

depois atribuo a esse objeto recuperado o objeto passado como parametro

dai só fazer o merge

Simples e pratico não :)

Espero que isso seja de ajuda para mais alguém. Até a próxima

Especialista – Sim ou Não?

2010-01-26T01:28:00.000-08:00

Um especialista é alguém com anos de pratica no seu serviço. Antigamente era algo muito comum, vide o filme Tempos Modernos de Charles Chaplin, ele era um especialista, em apertar parafusos, no final das contas, um especialista nada mais é do que alguém que passou a vida inteira fazendo a mesma coisa e no final não sabe fazer nada alem do que ele é especializado.

É comum eu ouvir muitas criticas, do tipo, você conhece um pouco de varias linguagens mais não conhece nenhuma muito bem. Na verdade o que eu não quero é ser dependente de uma única linguagem, digamos que sou especialista em Java (o que não é verdade), se um dia o Java morresse? Se um dia não existisse mais? O que eu faria?

Provavelmente não iria trocar de área, porém ia ter que me sujeitar a um cargo inferior ao meu para trabalhar com uma linguagem mais nova que eu ainda teria que aprender. Quando se tem uma base, é muito mais simples de evoluir na nova linguagem, você tem um conhecimento básico, e na área de T.I. onde existem mudanças frequentemente, você tem que estar apto a elas, e preparado. A especialização pelo menos na nossa área é passado, você não pode se ater a uma tecnologia, pois ele pode morrer amanha.

Por esses motivos prefiro sempre estar aprendendo, sempre atrás de coisas novas que me tornem um profissional melhor e mais apto.

Desculpem a demora por um novo post =).

Uma IDE na Nuvem

2009-11-24T14:10:00.000-08:00

A algum tempo atrás eu estava imaginando como seria uma IDE (ou editor de texto se preferir) usando cloud computing, fiquei imaginando como isso funcionaria e como seria agregado as empresas. A algum tempo atraz ouvi falar no Heroku Garden, uma IDE para desenvolvimento na nuvem para RoR, porém aparentemente o projeto foi abandonado. Esses dias olhando no forum do RubyOnBr, um cara comenta de um tal de Bespin, e eu resolvi procurar, eis que me surge o Mozilla Bespin, me registei e começei a brincar, achei o projeto promissor, vc pode criar projetos onde ele lista, vc tem uma linha de comando para utilizar, porém só funciona HTML, tentei usar PHP, Ruby, Java, e infelizmente a IDE ainda está engatinhando, o suporte é bem limitado, mas a interface gráfica é atraente.

Busquei os fontes do projeto e encontrei dois repositorios Mercurial, um para o server-side e um para o client-side, basicamente o backend do projeto roda em python e Java, e o front-end é uma mistura de JavaScript e JSON usando Prototype (pelo menos é parecido), para gerenciar as informações e enviar para o servidor.

baixei ambos os fontes, e estou ainda analisando, o servidor roda usando o virtualenv do python, ou seja emula uma maquina para que possa ser usado o servidor, infelizmente o README é precario quando a instalação, eu que sou leigo no virtualenv, apanhei um pouco até descobrir o easy_install para instalar as dependencias do projeto, ainda estou tentando por a IDE rodar na minha máquina. E acredito que valha a pena dar uma olhadinha no Bespin, mesmo que não haja muito o que fazer.

Parece que temos um projeto interessante saindo do forno.

Objetopolis

2009-11-17T15:28:00.001-08:00

Bem Vindo a Objetopolis.

Assim começa o segundo capitulo do livro Java! Use a Cabeça (Se não for também não interessa :P), copiei esse termo do livro, simplemente para ressaltar o que quero dizer.

Existem alguns que dizem que controlar o fluxo da informaçã com IFs é uma quebra ao paradigma orientado a objeto, porém nem todos os casos existe a necessidade de criar uma Interface e/ou ENUM para contornar IFs, salvo em alguns casos. Muitas vezes o excesso de abstrações para forçar/evitar o uso de algumas estruturas de controle ditas não-oo podem tornar o código menos legivel. Eu acredito que a beleza do codigo é grande parte da beleza de um sistema, concerteza um sistema bem escrito será um sistema que conterá a integração continua, e nenhum desenvolvedor que chegar até o sistema vai abandona-lo.

O que eu defendo quando se escreve um software é, pense em como vc vai ler isso aqui daqui a alguns meses, normalmente 1 mês basta para termos vontade de excluir todos os nossos codigos e reafaze-los aplicando novas tecnicas e funções, isso não é regra, mas como qualquer desenvolvedor que se preze está sempre em constante evolução seu novo conhecimento pode melhorar ou ajudar a escrever o codigo de forma mais elegante.

Apesar de tudo que eu disse sobre os IFs, eu não gosto de usa-los, acredito que deixa o código "tosco", existem situações em que ele é necessário. Muitos ifs podem ser evitados como por exemplo:


if( c == 0){

   return true;

}else{

   return false;

}

esse código é facimelmente convertido em uma linha:


return c == 0;

Em alguns casos o operador ternário tbm pode ser muito bem empregado, aumentado a legibilidade do código, lembre-se um sistema não é mais definido por linhas de código :D

Algo que eu gosto muito de fazer e usar um pouco de reflection, atrelado a um HasMap, com simples linhas de código temos um código mais legivel, como por exemplo, no item abaixo, abre-se uma determinada tela de um sistema utilizando esse recuro.


class Controller implements ActionListener{

   private Map> botoes = new HashMap>();



   public void actionPerformed(ActionEvent e){

          Class tela = botoes.get((JButton) e.getSource());

          if(tela != null){

                criaTela(tela);//Cria a tela para ser mostrada

          }else{

               raiseErro("Tela não encontrada!"); //monstra erro na tela

          }

   }

    public void registraBotao(JButton botao, Class tela){

          botoes.put(botao, tela);

    }

}

voila, temos um código limpo e facil de ser explicado, não existe problema em ler esse codigo, ele é completamente intuitivo, um único if, e um pouco de dinamismo, e lhes apresento um Controller desvinculado a uma tela. e se adiconar um botão não existe necessidade de criar um novo actionListener para abrir uma tela.

PS: esses exemplos foram criados a mão, aqui no blog, as chances disso não compilar são grandes, é meramente ilustrativo

Por isso que ressalto, muitas vezes para usarmos objetos, sempre que existe uma necessidade, cada objeto deve ter suas funções bem definidas, como li um dia o Sergio Taborda disse, se um objeto é somente para ser um apunhado de atributos com getters e setters que seja, desde que ele tenha sua funcionalidade bem definida.

Viajei nesse post, começei criticando algo que eu faço pra defenter o uso de objetos sempre hehhe.

Só mais um detalhe
Esqueçam os tipos primitivos, utilizem os wrappers A perca de performance é minima, e vc trabalha em um nivel superior aos tipos primitivos.

isso aí povo até mais.

Um poco de RSpec

2009-10-19T15:33:00.000-07:00

Estou focando um pouco dos meus estudos em RSpec e BDD, e é incrivel como existe pouco material em portugues sobre o RSpec, então, esse é um post rapido explicando como se validar algumas propriedades dos seus modelos no Rails usando RSpec.

PS: Estou utilizando I18n do Rails para a versão que eu traduzi do rails. seus erros podem estar na versão não traduzida, então o ideal é cuidar, pois seus testes podem não passar.

Validação um campo que deve ser informado.


#Imagine que User é uma classe de usuário qualquer
describe User do
  it "should be have an login" do
     @user = User.new
     @user.save
     @user.errors.on(:login).should be_eql("não pode ser em branco")#substitua essa string por seu texto customizado ou pela mensagem padrão em inglês
  end
end

Esse codigo simula a gravação de uma entidade, e verifica se existe o erro. lembrando que você deve adicionar na classe user:


class User < ActiveRecord::Base
  validates_presence_of :login
end

validando um número


#classe user.rb
validates_numericality_of :age, :only_integer => true
#user_spec.rb
it "should be have a valid number for age" do
  @user.age = "a"
  @user.save
  @user.errors.on(:age).should be_eql("não é um número")
end

Validanto tamanho de um campo


it "should be invalid when the name is greater than 100" do
  @user.name = "a"*101
  @user.save
  @user.errors.on(:name).should be_eql("é muito grande (máximo é 100 caracteres)")
end
#user.rb
validates_length_of :name, :maximum => 100

3 validações básicas para quem ta começando a mexer com o RSpec, não é lá grandes coisas, mas pode ajudar iniciantes em RoR a praticar o BDD.

[]'s

Rails - Editando o CSS do seu formário uma unica vez

2009-09-29T14:19:00.000-07:00

Acredito que todo o desenvolvedor tenha alguns problemas com CSS, ou de esquecer um maldito campo, e ele ficar sem o layout, muitas vezes, todos os campos são renderizados de maneira diferente, de acordo com a definição do designer, ou da equipe.
Normalmente o saco, é por exemplo em rails criar um form da seguinte maneira


- form_for(@foo) do |f|
  %p= f.error_messages
  %table
    %tr
      %td= f.label 'Nome:'
      %td= f.text_field :name, :class => :atext_field
    %tr
      %td= f.label 'Descrição:'
      %td= f.text_area :description, :class => :atext_area
    %tr
       %td= f.submit 'Salvar'

PS: Esse código foi escrito em HAML. é bem simples modifica-lo para ERB.
O que vemos é que existem dois campos com a tag :class, que indica a classe do componente para o Rails renderizar na tela. Eis que nessa tela imagine mais uns 10 text_field, e outras páginas de cadastro com quantidades semelhantes de campos. Ai o desgraçado do design resolve mudar o layout (não me levem a mal designer, muitas vezes vocês nos dão raiva mesmo, :D), e para mander compatibilidade ele cria outras tags, e la veio no minimo meio dia de serviço para ajustar esses campos ai para o nova classe (por ex: btext_field).

Mas vamos relembrar um conceito simples do Ruby as classes abertas. Nessa situação é um modulo (module), que gerencia os forms, o querido ActionView::Helpers::FormTagHelper.
Ele é o responsavel por renderizar esses objetos. agora basta simplesmente você alterar esse modulo, veja como fazer (editei no meu environment.rb, como ele não é recarregado tem que para o servidor e iniciar novamente, vocês podem fazer esse código em qualquer lugar)


module ActionView
  module Helpers
    module FormTagHelper
      def text_field(object_name, method, options={})
        super object_name, method, options.merge(:class => :btext_field)
      end
      def text_area(object_name, method, options={})
        super object_name, method, options.merge(:class => :btext_area)
      end
      def check_box(object_name, method, options={}, checked_value="1", unchecked_value = "0")
        super object_name, method, options.merge(:class => :bcheck_box), checked_value, unchecked_value
      end
    end
  end
end

Caso não conheça o metodo merge dos hash do ruby, seria interessante conhece-lo, dessa maneira, não existe mais a necessidade de definir o atributo :class em cada text_field, essa alteração coloca automáticamente essa informação disponivel. Existem coisa que o ruby faz que surpreendem :D.

Perf4j - Analise de performance em Java

2009-08-24T10:05:00.000-07:00

Acredito que a maioria dos desenvolvedores ao menos uma vez mediu o tempo de execução de um método na aplicação. Para quem como eu meche com Java, muitas vezes recorremos ao System.currentTimeMillis():


 Long agora = System.currentTimeMillis();
 //Algum método demorado
 System.out.println((System.currentTimeMillis()-agora)+"ms");

A saída desse código é o tempo de execução em milisegundos, bem simples, já é algo ilustrativo para medir o desempenho da aplicação, porém muitas vezes isso não tem todas as informações que gostaríamos de ter.
Eis que algum louco inventou um tal de perf4j, uma biblioteca parecida com o log4j, mas voltada para medir a performance da aplicação (O log4j é uma biblioteca de log). Através do perf4j, é possível até gerar gráficos de desempenho, e ele também mostra o tempo médio de execução dos métodos durante a execução.
Vou mostra uma maneira simples de se usar o perf4j mesclado com o Java Logging API, assim podemos salvar os resultados da performance em um arquivo e lê-los quando precisarmos.
O perf4j funciona baseado na classe StopWatch, e apartir dela podemos gerar as nossas estatísticas. Inicialmente o código vai ficar maior porém os dados que podemos conseguir em cima disso são bem maiores.

OBS: Já tive problemas com essa manipulação de arquivos e locks do Sistema operacional, quando estamos trabalhando com arquivos, o ideal é sincronizar e tornar a leitura do arquivo Thread Safe


String arquivo = "statistics.log";//nome do arquivo que será armazena as estatisticas
Logger logger = Logger.getLogger("com.rollingwithcode");//Qualquer pacote serve.
logger.addHandler(new FileHandler(arquivo));//adiciona ao log o arquivo como handler, a Java Logging API, usa esse arquivo para armazenar o log.
StopWatch stop = new JavaLogStopWatch("Teste", logger);//o primeiro argumento é o nome ilustrativo desse log, cada método deve ter seu próprio nome, assim se torna mais intuitivo e mais especifico quando se lê o arquivo.
//Aqui vem alguma execução que pode ser demorada.
stop.stop();

Após a execução da ultima linha algo como:
24/08/2009 13:43:32 org.perf4j.javalog.JavaLogStopWatch log
INFO: start[1251132212406] time[406] tag[Teste]
Deverá ser exibido na console. Essa saída é até menos legível que a do System.currentTimeMillis(), porém o poder do per4j será mostrado a seguir.

Vamos ler o arquivo de log gerado, seria interessante executar mais alguns métodos para armazenar no log, o per4j trabalha com uma classe chamada LogParser para gerar estatísticas em cima do arquivo de log gerado (statistics.log).


String arquivo = "statistics.log";
String temp = "lido.log";//Arquivo temporário, os dados são jogados do statistics para esse outro arquivo de log.
LogParser parser = new LogParser(new BufferedReader(new FileReader(arquivo)),
                        new PrintStream(new FileOutputStream(temp), true), null, 30000L, false,
                        new GroupedTimingStatisticsTextFormatter());
parser.parseLog();

A criação do LogParser é simples, primeiro argumento é o arquivo de log que geramos através do StopWatch, o segundo é o arquivo temporário a ser salvo, o terceiro parâmetro (null) é utilizado para gráficos, os outros dois parametros não vem ao caso agora, o ultimo parâmetro é o formatador do arquivo temporário, define o layout do arquivo.

O método parseLog faz a leitura do arquivo. Agora basta você ver o arquivo lido.log e termos o arquivo legível trazendo a media de tempo de execução do arquivo (Avg), o tempo mínimo (Min), o tempo máximo (Max), a quantidade de vezes que o método foi chamado (Count). Agora sim as informações são bem maiores não acham?

Aconselho o uso do perf4j, excelente ferramenta para analise de performance em Java.

.COM

2009-08-10T09:14:00.000-07:00

Agora o Blog é .COM :)

Continua sendo hospedado no blogger, mas para acessar ficou mais facil

RollingWithCode.com

Esse post é só pra falar isso outra hora posto algo util :)

[]'s

Java ScriptEngine

2009-07-31T03:33:00.000-07:00

Estava eu pensando esses dias, se posso executar código java via Jruby por que não o contrário? Quais as minhas chances de usar Jruby dentro do Java?
Então la fui eu ao oraculo, e começei a buscar, ouvi falar de um JSR XXX (preencha com o número que quiser, nunca me lembro desses números, que pra mim são irrelevantes), que define o Java ScriptEngine, que nada mais é do que usar scripts dentro do Java, no Java 6, já vem com superte a Rhino (JavaScript), embutido, mas exemplos usando JavaScript tem de monte, vou lhes mostrar como instanciar uma classe via JRuby e chamar alguns metodos dessa classe no java. Não vou dizer que isso vai ficar bom, mas enfim, quem sabe melhorem futuramente essas engines, Mesmo assim você não precisa massacrar seu codigo java para migra-lo para JRuby, pode simplemente adaptar o codigo do JRuby no Java. Vamos ao exemplo, primeiramente vejamos quais nossas engines disponiveis na nossa versão.


import javax.script.ScriptEngineFactory;

import javax.script.ScriptEngineManager;



public class Main {



    public static void main(String[] args) throws Exception{

        ScriptEngineManager manager = new ScriptEngineManager();

        for(ScriptEngineFactory factory : manager.getEngineFactories()){

            System.out.println(factory.getEngineName());

        }

    }

}

A saida deve ser Mozilla Rhino, lembre-se java 6, eu não tenho bem certeza, mas acho que o ScriptEngine está disponivel na versão 5, porém sem nenhuma engine disponivel.
E ai tio e agora como que nos faz?
Vamos adicionar o Jruby, no site do projeto baixem os script-engines, com isso temos as libs de diversas linguagens suportadas que podemos utilizar, para nos interessa, o que esta dentro da pasta jruby/build, o jruby-engine.jar deve ser adicionado ao seu classpath, ainda existem outro jar a ser adicionado, se você olhar outros tutoriais, ele vai passar diversos jar que não estão mais no $JRUBY_HOME/lib, ignore :), adicione ao classpath do seu projeto somente o jruby.jar, e agora sim. Se executar o programinha de antes deve aparecer agora



Mozilla Rhino

Jruby Engine

Vamos para o nosso querido Hello World (eu sei, eu sei, todos vocês amam o Hello World (: )


import javax.script.ScriptEngine;

import javax.script.ScriptEngineManager;



public class Main {



    public static void main(String[] args) throws Exception{

        ScriptEngineManager manager = new ScriptEngineManager();

        ScriptEngine engine = manager.getEngineByName("jruby");//Buscamos a Engine do Jruby

        engine.eval("puts 'Hello World'");//Codigo JRuby

    }

}

ao executar temos a mesma saida do Println, não é magico? Heeheh, um puts executado via java. Sei exatamente o que a maioria pensou, vou ter que por todo o codigo Jruby num String? A reposta é não :), a não ser que você queira fazer isso, mas eu não aconselho.
Existem outros metodos para recuperar as engines, e um deles é por extensão, poderiamos ter usado o metodo getEngineByExtension e passar como parametro o “rb”, e teriamos o Jruby.
Vamos criar então uma classe bem bunito um arquivo .rb


class Teste

  attr_accessor :name, :age



  def set_name(name)

    self.name = name

  end



  def set_age(age)

    self.age = age

  end



  def toString

    self.name+" "+self.age.to_s

  end

end

Lembrando que o toString sobrescreve o metodo toString do java sem problemas algum, os metodos set_ foram definidos para seguir as convensões do ruby, e isso vai tornar nosso codigo java feio, e não digam que não avisei. Vamos criar uma pequena interface


public interface Teste {

    String name();

    void set_name(String name);

    Integer age();

    void set_age(Integer age);

}

notem o estilo que foi declarado os metodos set_ na interface tbm, deve haver alguma maneira de fazer isso automatico, se alguem souber me avisa :)

E agora tio? Vamos brincar um pouco de ScriptEngine?


public static void main(String[] args) throws Exception{

        ScriptEngineManager manager = new ScriptEngineManager();

        for(ScriptEngineFactory factory : manager.getEngineFactories()){

            System.out.println(factory.getEngineName());

        }

        ScriptEngine engine = manager.getEngineByName("jruby");

        engine.eval(new FileReader("src/com/rollingwithcode/testejruby/teste.rb"));//arquivo .rb

        Object instance = engine.eval("@teste = Teste.new");//crio a instancia

        Invocable inv = (Invocable) engine;

        Teste teste = inv.getInterface(instance, Teste.class); //converto a classe em uma Interface Java

        teste.set_name("Rafael");

        teste.set_age(21);

        System.out.println(teste.toString());

        System.out.println(teste.name());

    }

E adivinhem a saida:



Rafael 21

Rafael

Tudo isso só pra misturar um pouco de Ruby com java, credo, parece coisa de loco :)

vou investigar mais algo, e ver se existem maneiras de melhorar isso.

Abraços até a próxima

Java e LDAP

2009-07-04T05:50:00.000-07:00

É engraçado ver como os servidores LDAP não vem sendo aproveitados. Na verdade são poucas as linguagens onde a comunidade tem algo para usar com servidores LDAP. No caso do Java existe uma biblioteca o JLDAP, distribuida pela Novell que ajuda o trabalho. É uma biblitoeca bem sfemples e mais facil de utilizar que usar JNDI para comunicar com o servidor LDAP.
Porém muita gente tem dificuldade em criar o servidor e efetuar ações dentro de um servidor LDAP, vou utilizar aqui nesse exemplo o Apache Directory Server como servidor LDAP, então as strings de acesso vão depender muito do servidor que você estará utilizando. Existem ferramentas para explorar os servidores então pode não ser tão dificil assim, basta dar uma espiada no senhor da internet (Google) e acharás o que procuras :).
Começando com o JLDAP:
A base de uma conexão com o servidor LDAP é baseada na classe LDAPConnection, e diferente dos banco de dados, não é a conexão que importa e sim o bind dela. Atraves desse bind o servidor disponibiliza os recursos de acordo com as permissoes do usuário que fez o bind. Exemplo:


LDAPConnection conn = new LDAPConnection();

conn.connect(“localhost”, 37); //Esses dois parametros são servidor (IP ou Nome) e a porta de conexão

conn.bind(LDAPConnection.LDAP_V3, “uid=admin,ou=system”, “secret”.getBytes());

Percebam o bind, ele é composto por versão do servidor LDAP, o DN do usuário a ser logado, lembrem-se o LDAP não funciona como usuário e senha, e talvez precisem ler mais sobre ele e suas siglas, DN, CN, RDN etc. E o ultimo parametro e a senha em um array de byte.
Após esse código existe uma conexão com o servidor LDAP. E podemos manipula-la.
Vamos criar uma nova entidade dentro do servidor LDAP. Vou utilizar a classe Person (Os servidores LDAP também são divididos em classes, são chamadas de objectClass, e essas classes identificam o tipo do registro no servidor), responsavel por cadastrar usuários no servidor LDAP.


LDAPAttributeSet attributes = new LDAPAttributeSet();//Um Set de atributos para o servidor, funciona no formato chave => valor.

attributes.add(new LDAPAttribute("objectClass", "person"));

attributes.add(new LDAPAttribute("cn", "felix"));

attributes.add(new LDAPAttribute("sn", "felix"));

attributes.add(new LDAPAttribute("userpassword", "teste"));

attributes.add(new LDAPAttribute("telephonenumber", "11111111"));

attributes.add(new LDAPAttribute("description", "Eu"));

//Definimos o DN, lembrem-se ele sempre é único e tera uma exception caso não seja único

String dn = "cn=felix,ou=users,ou=system";//Isso pode variar de acordo com o servidor LDAP que você estiver utilizando.

LDAPEntry entry = new LDAPEntry(dn, attributes);

conn.add(entry);//insere a entidade.

bacana Não é? E o mais legal, funciona :). Levei algum tempo para conseguir isso, mas assim é mais simples. Lembrando que deve-se ter um conhecimento básico em LDAP. O dn é formado normalmente pelo cn do usuário e o restante compreende a hierarquia de arvore do LDAP. Vendo como um diretorio seria um arquivo chamado felix dentro da pasta users que esta dentro da pasta system, simple não? E ainda por cima vc pode usar esse DN recem inserido para fazer login no servidor LDAP.
Vamos para a segunda parte. Pesquisar registros.
A pesquisa é baseada na classe LDAPSearchResults, e se basea na busca atraves da arvore de diretorios ou de um DN. A pesquisa aqui vai ser baseada na árvore que acabamos de inserir um registro (ou=users,ou=system), e vamos ver todos os usuários do sistema.


LDAPSearchResults search = conn.search(“ou=users,ou=system”, LDAPConnection.SCOPE_ONE, null, null, false); //não to lembrado do por que desses parametros :P

while(search.hasMore()){//Auto explicativo

	LDAPEntry entry = search.next()://Recuperamos a entidade. Cada uma dessas entidades é um usuário do servidor LDAP.

	//Vamos carregar e imprimir os atributos desse usuário

	LDAPAttributeSet attribute = entry.getAttributeSet();

	Iterator it = attribute.iterator();

	while(it.hasNext()){

		LDAPAttribute att = (LDAPAttribute) it.next();

		System.out.println(att.getName() + “ => “ + att.getStringValue());

	}

	System.out.println();

}

Simples não? E ainda tem gente que acha dificil acessar servidor LDAP via Java :)

Espero que esse post seja util a quem está buscando algo como acessar servidores LDAP.

Swing e TestUnit (JUnit)

2009-06-17T07:09:00.000-07:00

Quem já mecheu com Swing conheçe o parto que é testar as telas. Pensar nas mil possibilidades se fazer cagada em uma tela. Impossivel prever o total de coisas que um usuário consegue fazer. Para facilitar esses testes surgiu o JUnit, automatizando os testes. Não vou entrar em detalhes sobre o TDD, existe muita informação por ai.

Mas algum tempo atrás procurei por algo para automatizar os testes em Interfaces gráficas. Porém nada do que eu achei era o que eu buscava. Não queria ter que abrir a tela e inserir valores. Gostaria de fazer isso via código de forma automatica, como o JUnit, em busca de um resultado esperado. Vi sobre o Maraton, FestSwing, e em todos eu tinha que abrir a droga das telas para testar. Algo que não me agradou nem um pouco.

Então deixei de lado isso. Porém alguns dias atraz me veio uma ideia meio louca de se fazer isso. Criei uma classe que encapsula o frame. e atraves dela consigo recuperar os compoenentes da tela e simular as ações. Exatemente o que eu queria. Automatizar a porcaria do teste (:

Image o seguinte JInternalFrame:

A ação do botão se resume a alterar o texto de JInternalFrame para Clicked.
E ai? como fazer para testar esse esquema?


public class TestFrameWithMock {

   private SwingTester mock;



   public TestFrameWithMock() {

       mock = new SwingTester(new TesteInternal());

   }



   @Test

   public void shouldChangeTextWhenButtonWasClicked(){

       JButton btn = (JButton) mock.getFieldReflect("jButton1");

       JTextField tf = (JTextField) mock.getFieldReflect("jTextField1");

       assertEquals("JInternalFrame", tf.getText());

       btn.doClick();

       assertEquals("Clicked", tf.getText());

   }

}

E ai alguém ai percebeu como é simples o esquema? E nenhuma tela é visivel. A maioria das ferramentes você deveria abrir cada JInternalFrame, um por um e testa-lo. Assim desse modo com a Classe SwingTester ele não é visivel.

Como podem perceber o TesteInternal (JInternalFrame da imagem) é passado como parametro. E atraves dele é possivel recuperar os compoenentes da tela atraves do atributo name de cada um ou atraves do nome da variavel via reflection (que foi usado nesse teste acima). E o teste executa sem problemas.

Foi a abordagem que achei mais legal. Em breve for colocar isso ai no github, se eu lembrar e vcs podem analisar e testar.

Ioke - Programação Orientada a Protótipo

2009-06-08T15:35:00.000-07:00

Eu em alguns devaneios que acredito que todo o programador tenha (Por favor confirmem isso :) ), estava em busca de uma linguagem funcional para aprender, seguindo o conceito de aprender uma linguagem nova por ano, esse ano estava atrasado, ainda não tinha começado a estudar nenhuma linguagem, estão buscando pela linguagem Haskell que havia escutado bem, e também dei uma olhada em Erlang outra linguagem funcional crescendo em uso. Muitos devem se perguntar, por que não Scala? Na verdade cada vez que busco fugir um pouco da filosofia Java, eu melhoro meus códigos em Java, assim como Scala seguem a mesma família, pois sua sintaxe lembra bastante a sintaxe Java.

Então olhando as duas linguagens entrei em um dilema, qual aprender? e foi a duvida, dei uma olhada básica, não me aprofundei muito em nenhuma das duas. e Algum tempo atras, navegando em alguns blogs, cheguei em um que continha uma entrevista com Ola Bini, que é um dos principais desenvolvedores do JRuby, onde ele afirmava que Java é muito baixo nivel é que é excelente para se criar novas linguagem (seria essa uma afirmação do tipo Java é o novo C?), e na mesma entrevista ele citava Ioke, a linguagem de programação que ele havia criado, utilizando Java. E eu resolvi dar uma olhada, e vi que ela é uma linguagem orientada a prototipos, não orientada a objetos. E isso me chamou a atenção, em algumas buscas, encontrei no Groups do Ioke, um brasileiro, que me ajudou a esclarecer algumas dúvidas.

No site do Ioke possui diversos exemplos de como se utiliza ele.
O Ioke possui suporte nativo a Java, e não utiliza o operador . , tão comum para as linguagens atuais, eis que vendo esse suporte nativo resolvi criar uma Bridge de JDBC com o Ioke, e por incrivel que pareça, e depois de algum sofrimento consegui excecutar uma consulta no banco. Algo realmente bacana para quem está aprendendo uma linguagem nova. Mas muito da API não consegui usar, o que consegui foi instanciar classes dos Drivers diretamente.

o Ioke ainda possui o iik que é um console iterativo estilo o irb do Ruby, e ainda possui o iSpec baseado no RSpec, ainda não mechi muito nisso, mas estou gostando desse novo aprendizado, aos poucos vou colando alguns códigos do Ioke para vocês verem.

Só não esperem um hello world por que fazer um "Hello World" println é muito simples não acham?

O material na web ainda é escasso e a linguagem é lenta, mas acredito que tudo isso pode mudar :).

Vamos ver como o Ioke se sai com o tempo.

até a próxima.

Mais um passo

2009-05-28T15:36:00.000-07:00

Bom terça-feira dia 24/03/2009 foi minha apresentação do meu trabalho de conclusão de curso.
Engraço que tudo isso me fez lembrar do começo da faculdade, desde quando entrei, até agora. E pensar que entrei sem nem ter noção do que era desenvolver um software, e hoje ser um desenvolvedor.

Na verdade quase me dei mal na apresentação, no nervosismo apresentei em 11 minutos quando deveria ter apresentado em 15, fui mostrar a apresentação utilizando uma digamos assim "gambiarra", para mostrar funcionando a aplicação, mas Murphy é infalivel e a aplicação não funcionou, na hora o branco de não saber como agir me deixou sem muitas escolhas, mas no fim correu tudo bem, mesmo sem mostrar a aplicação. Eu espero ao menos. Ainda me resta entregar o trabalho escrito, mas esse só ajustar a metodologia dele.

Do que se tratava meu trabalho, basicamente é uma ferramente para alterar usuários em um servidor LDAP atraves do Celular.
Utilizei somente linguagem Java, JSON, RESTful e o Apache Directory Server.
O sistema atraves do emulador executa todo o CRUD sobre um Usuário do servidor LDAP, porém rodando do aparelho existe um problema na edição de usuários. E a aplicação não está tão completa, faltaram validações, e diversas implementações. Algumas coisas faria melhor, mas nem sei se vou continuar com o projeto.

O projeto na verdade é divido em 4 partes, a API de comunicação com o LDAP, a implementação da API, focada no ApacheDS, os serviços RESTful, e a aplicação cliente. Os fontes são interessantes para quem quer ver como funciona a comunicação com o LDAP partindo do Java, e como utilizar JSON tanto em Java como em JavaME.

Abaixo minha apresentação:

Apresentacao TCC - Rafael Felix

View more OpenOffice presentations from felix.rafael.

E os códigos estou disponibilizando via RapidShare:
Aqui

Façam bom uso nos estudos :)

Java e JSON

2009-04-29T16:05:00.000-07:00

O título apesar de estranho, é justamente disso que vou falar JSON com Java (café), andei pesquisando diversos formatos de arquivos para usar no meu TCC, dentre eles o XML, que para quem não sabe é muito custoso para um celular processar esse tipo de arquivo, o YAML (o qual não possui nenhum biblioteca para ser tratado com JME), e o ultimo é o que eu mais me encantei o JSON.

JSON foi criado baseado em JavaScript. Porém ganhou notaridade, e foi implementada por diversas linguagens, no site oficial se encontra uma biblioteca para ser usado em Java, com o codigo fonte la. Foi esse que usei nesse exemplo, podem baixar nesse link http://www.json.org/java/index.html

Muito simples trabalhar com JSON e Java. O JSON funciona como um Map, utilizando a combinação chave => valor, uma chave sempre é uma String, e o valor pode varias, os valores disponiveis para o JSON podem ser vistos no site json.org.

Após adicionar as classes ao seu projeto vamos a utilização da biblioteca.
Basicamente a biblioteca consiste nos objetos JSONObject, JSONArray e JSONException
Onde JSONObject representa um único objeto no formato JSON e JSONArray representa uma coleção de objetos.

Usando JSONObject


JSONObject obj = new JSONObject();

obj.put("nome", "Rafael");

obj.put("idade", 21);

System.out.println(obj);

a saída sera algo como:


{ "nome":"Rafael", "idade":21 }

Perfeito não? muito simples. Calma que tem mais


public class Pessoa{

   private String nome;

   private int idade;



   //Gets e Sets

}

Criamos um objeto para comportar as alterações. e para converte-lo em JSON?


   Pessoa p = new Pessoa();

   p.setNome("Rafael");

   p.setIdade(21);

   JSONObject obj = new JSONObject(p);

   System.out.println(obj);

E a saída?


{ "nome":"Rafael", "idade":21 }

Um JSONArray segue a mesma linha de raciocionio, com a diferença que vc adiciona a ele diversos JSONObject ou Strings no formato JSON. excelente para quem quer trabalhar com esse arquivo em formato leve.

É isso ai.

Criando seus proprios eventos no Java

2009-04-15T15:50:00.000-07:00

A maioria do pessoal que já mexeu com Swing no Java (o que acredito que sejam a maioria do pessoal que já mexeu com java), conheçe o estilo do java tratar eventos, usando classes, assim como nossa querida classe chamada ActionListener, que algumas IDEs como o Netbeans escondem a declaração dessa interface, adotando um estilo mais delphi-style.

E normalmente o pessoal que vem do Delphi, acha estranho declarar um classe e implementar um metodo nela para executar o evento de um botão (Eu também achava isso). Porém os beneficios de adotar esse abordagem, proporciona baixo acoplamento, e seu código pode se tornar mais dinamico e orientado a objetos, não aquele código macarronico que vemos por ai, que muitas pessoas fazem, e eu também faço diversas vezes.

A vantagem de se fazer isso é que o Java não vai sobrescrever o ActionListener que já foi adicionado ao seu botão, ele vai adicionar mais um, ou seja seu botão vai executar duas ações. ou seja, vc pode separar códigos com mais facilidade, e muito mais simples. Mas bah tche como isso?

Vou mostrar como criar seus proprios eventos em Java. Imagine o seguinte problema:

"Como projetar um sistema que modele um telefone e todos os objetos que poderiam estar interessados quando ele toca?"

Rá, ai poderiamos usar o Observer, que expliquei no artigo anterior correto? Sim, poderiamos, mas não é isso que eu quero mostrar :-)

Primeiramente devemos criar o Evento, esse evento será o evento disparado toda a vez que um telefone toca, e vai ficar disponivel para os listeners, é um código realmente simples:


public class TelefoneEvent extends java.util.EventObject {



    public TelefoneEvent(Telefone source) {

        super(source);

    }

}

Simples não, deixemos a herança cuidar disso para nós e o java que cuide de seu EventObject

Agora vamos criar nossa interface Listener, utilizando listener não impedimos a herança, e deixamos a classe livre para criar quantos listeners quiser, ou implementar se for melhor para ela, a implementação do listener


public interface TelefoneListener extends java.util.EventListener {

    void telefoneTocou(TelefoneEvent e);

    void telefoneAtendido(TelefoneEvent e);

}

Extendendo a interface EventListener, temos um novo evento criado, nosso telefone Listener, possui dois metodos, telefoneTocou e TelefoneAtentido, que devem ser reimplementados, uma solução bacana que o java usa também são os adapters, como KeyAdapter, que possui os metodos de KeyListener implementados sem código ou funcionalidade alguma, vc so sobrescreve os que deseja, os outros são silenciosos (não fazem nada).


public class TelefoneAdapter

    implements TelefoneListener {



    public void telefoneTocou(TelefoneEvent e) {}

    public void telefoneAtendido(TelefoneEvent e) {}

}

Simples não, mas não é só isso, ainda não serve para nada nosso listener.


//imports omitidos

public class Telefone {

    private Collection  telefoneListeners = new ArrayList();



    // método de suporte para testar a solução

    public void tocaFone() {

        disparaTelefoneTocou();

    }



    public void atendeFone() {

        disparaTelefoneAtendido();

    }



    public synchronized void addTelefoneListener(TelefoneListener l) {

        if(!telefoneListeners.contains(l)) {

            telefoneListeners.add(l);

        }

    }



    public synchronized void 

            removeTelefoneListener(TelefoneListener l) {



        telefoneListeners.remove(l);

    }



    private void disparaTelefoneTocou() {

        Collection  tl;

        synchronized (this) {

            tl = (Collection)(((ArrayList)telefoneListeners).clone());

        }

        TelefoneEvent evento = new TelefoneEvent(this);                

        for (TelefoneListener t : tl) {

        	t.telefoneTocou(evento);

        }

    }

            

    private void disparaTelefoneAtendido() {

        Collection  tl;

        synchronized (this) {

            tl = (Collection)(((ArrayList)telefoneListeners).clone());

        }

        TelefoneEvent evento = new TelefoneEvent(this);

        for (TelefoneListener t : tl) {

        	t.telefoneAtendido(evento);

        }        

    }

}

Essa é uma simples classe como outra qualquer, podem ver que ela possui dois metodos addTelefoneListener e removeTelefoneListener, esses metodos são padrões, em listeners vc não pode utilizar getters e setters, utilizando getter e setter perde-se o encapsulamento. Ele cria antes de disparar os eventos de cada um dos seus listeners, simples e prático.


public class SecretariaEletronica

    implements TelefoneListener {



    public void telefoneTocou(TelefoneEvent e) {

        System.out.println("Secretaria escuta o telefone tocando.");

    }



    public void telefoneAtendido(TelefoneEvent e) {

        System.out.println("Secretaria sabe que o telefone foi atendido.");

    }

}

public class Pessoa {

    public void escutaTelefone(Telefone t) {

        t.addTelefoneListener(

            new TelefoneAdapter() {

                public void telefoneTocou(TelefoneEvent e) {

                    System.out.println("Eu pego!");

                    ((Telefone)(e.getSource())).atendeFone();

                }

            }

        );

    }

}

Duas classes para melhorar a brincadeira, e vc pode criar mais classes, essas somente ajudam a ilustrar o exemplo


public class ExemploFone {

    public static void main(String[] args) { 

        Telefone fone = new Telefone();

        Pessoa fulano = new Pessoa();

        SecretariaEletronica se = new SecretariaEletronica();



        fone.addTelefoneListener(se);

        fulano.escutaTelefone(fone);



        fone.tocaFone(); // começa a brincadeira

    }

}

a saida é algo assim



Secretaria escuta o telefone tocando.

Eu pego!

Secretaria sabe que o telefone foi atendid

Pode parecer complexo inicialmente, mas isso melhora e agiliza o trabalho, é muito bacana se trabalhar com listeners. Esse exemplo foi encontrado aqui e vc pode utiliza-lo, possui mais detalhes.

Uma leitura bacana, veja aqui no blog do Carlos Brando.

Implementando Obsever em Java

2009-03-30T03:35:00.000-07:00

Segundo a wikipedia:
O padrão obsever diz que um objeto (observado) mantem uma lista de outros objetos (observadores), e notifica aos observadores qualquer mudança que ocorro no observado.

O Java já traz uma implementação do observer padrão, e a utilizamos aqui onde trabalho pra implementar o MVC com Swing, e realmente achei uma abordagem muito interesse, e simples de ser feita.

é muito simples de se utilizar, e esse post vai ser pequeno sim :).

primeiramente na nossa classe observada temos que fazela extender a Obervable e isso já a torna apta para ser observada por outra classe, as classes que vão observala devem implementar a interface Observer que contem a assinatura de um único metodo update, a cada notificação do modelo é chamado esse metodo update, ridiculamente simples e facil.

Vamos a um exemplo prático:


public class MeuObservado extends Observable{



  public void hello(){

     setChanged();

     notifyObservers("Hello World!");

  }



}

Agora quem vai observar essa classe


public class MeuObservador implements Observer{

    public MeuObservador(){

        MeuObservado obj = new MeuObservado();

        obj.addObserver(this);

        obj.hello();

    }

    public void update(Observer o, Object arg){

        System.out.println(arg);

    }

}

só executar e pronto, um hello world utilizando observer, se vc tiver mais classes que utilizem esse hello world basta adiciona-la ao observer, e ela será notificada também. simples, pratico e facil. Excelente maneira de proporcionar baixo acoplamento entre as classes.

Outra hora vou postar sobre como criar listener no Swing.

[]'s

CouchDB-J

2009-03-09T15:28:00.000-07:00

O CouchDB, é um banco de dados Orientado a documentos, diferente dos banco de dados orientados a tabelas, ele é mais dinamico, e dizem por ai que ele escala, diferente dos banco de dados relacionais. CouchDB é um projeto da apache, e nem na versão 1.0 está ainda, mas já causou enorme alvoroso na comunidade Rails. Existem algumas soluções para usar o CouchDB com Rails, e em java temos somente uma que é o CouchDB4J, mas para mexer com ela é necessário reaprender a mexer.

Lógico que a estrutura do CouchDB é bem diferente de outros banco de dados, ele funciona a base de requisições RESTful, e troca arquivos no formato JSON, entre cada Requisição, ele é baseado em Requests e Responses HTTP.

Eis que procurando, até para testar não há nenhuma implementação que tente seguir o padrão JDBC para o CouchDB, então, começei a implementar, e nem é tão complexo assim, secretamente em baixo de cada comando ha uma requisição HTTP no projeto. Vou em breve disponibiliza-lo no meu github, para quem quiser contribuir, a versão já tem algumas informações uteis, já é possivel consultar alguns documentos do servidor atravez de ResultSet e Statment.

Quem tiver interesse em ajudar, é só falar comigo para começarmos a pensar em como desenvolver melhor esse driver.

Ficou interessado no CouchDB?
Infelizmente ele ainda não tem uma distribuição em binários, somente código fonte. Podem baixar os fontes, e ver no README do CouchDB como instalar no Ubuntu e no Mac OS, usuários de windows, tentem novamente mais tarde.

Ele possui uma interface web bem simples e bacana para se aprender a mexer, estou querendo aprender a mexer mais, se alguem quiser compartilhar conhecimentos so falar comigo.

@Annotations

2009-02-18T02:39:00.001-08:00

O que são as annotations?
Na verdade uma annotation não é nada, somente um enfeite para seu código. WTF? então como elas servem para fazer alguma coisa? Como que eu anoto com @Id meu JPA e ele reconheçe isso?

Na verdade não é a anotação que vai fazer isso, e sim uma outra classe responsavel por ler suas classes e identificar quais possuem a anotação, e você que criou aquela anotação simples, vai ter que escrever essa classe. Calma não se desespere, vou explicar como funciona :).

Para criar uma Anotação devemos criar uma interface Java, mas com algumas pequenas mudanças vejam a anotação abaixo


public @interface Teste{
  String valor();
}

pronto temos uma anotação criada, o campo abaixo é um atributo da anotação algo que a anotação deve obrigatoriamente conter, você pode deixa-la opcional, adicionando a opção "default"


public @interface Teste{
  String valor() default "";
}

As anotações são objetos simples, e eles não aceitam valores null. Vc não pode passar um objeto por exemplo seu JPA para uma anotação (infelizmente).

E agora para usar como q faz?
vamos criar uma classe de ajuda para nós aqui, ela será a classe que irá executar o comando:


public class Main{
 @Teste(valor="teste")
 private String teste;

 public static void main(String[] args){

 }
}

Nossa anotação esta funcionando, mas se vc executar o programa vc simplesmente não verá nada. Mas por que? A Anotação é so um enfeite, existe toda uma programação em reflection por traz (gambiarra?), mas não é tão complicado assim, vamos criar uma classe AnnotationResolver, que vai verificar as anotações para nós:


public class AnnotationResolver{
  private Class classe;
  private Field[] fields;
  public AnnotationResolver(Class classe){
     this.classe = classe;
     //Isso é reflection carregamos todos os campos da classe informada
     //Esses campos são todos os atributos declarados na classe.
     this.fields = classe.getDeclaredFields();
  }
  public void resolve(){
      for(Field f : fields){
          //Eis aqui a magica do reflection
          //Perguntamos se o campo tem uma anotação, e informamos a classe dessa anotação
          if(f.isAnnotationPresent(Teste.class){
               //Podemos pegar a instancia da anotação desse campo dessa maneira, e assim
               //acessar os campos da anotação
               Teste teste f.getAnnotation(Teste.class);
               System.out.println(teste.valor());
          }
      }
  }
}

Para testar nossa classe vamo esditar o metodo main da classe Main, o restante do código já informado acima foi omitido


//Codigo omitido
public static void main(String[] args){
  new AnnotationResolver(Main.class).resolve();
}

Simples assim temos nossa chamada e veremos nossa anotação funcionando, execute o programa. E vamos ao resultado:

Nada.

WTF? O Que eu fiz errado? por que isso não funciona?
Bom apanhei muito para isso funcionar, a anotação tem que ter algumas anotações também (rá), primeiro você deve indicar em que momento a anotação deve ser verificada e depois informar qual o objetivo dela, se ela atige Classes, Metodos ou campos. basta editar nossa anotação e adicionar:



@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Teste{
//Codigo omitido
}

Meio estranho fazer isso mais eu sempre uso o @Retention como RUNTIME, pois é normalmente a hora que eu gosto que as anotações sejam conferidas. Agora compile e rode seu programa.

E veja só não é que funcionou?
Agora sim você tem um enfeite util para seu projeto Java (nem tão util assim no nosso exemplo).

De uma conferida no docs da sun:

http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html

JME com RESTful

2009-02-16T02:01:00.000-08:00

Esse eu descobri fuçando na net, pois a muito pouco material sobre isso, que seria como usar o metodo PUT utilizando JME. Atualmente estou na 9ª fase do Curso de Ciência da Computação na UNOESC, a ultima fase do curso, e estou desenvolvendo meu TCC (Trabalho de Conclusão de Curso), meu projeto consiste em prover acesso a um servidor LDAP (O padrão LDAP, não em um serviço especifico), pelo celular, na verdade irei construir somente um prototipo da aplicação aonde seja possivel criar, editar, excluir e listar os usuários do LDAP.
No começo do projeto, minha intenção seria usar Web Services (XML) e consumir os retorno com o JME, porém ao pesquisar as APIs de consumo de XML para JME, elas são mal documentadas, e os exemplos são criados pela comunidade, algumas APIs você nem acha aonde baixar. Sem contar que o consumo de XML no celular é muito custoso para o aparelho que não tem muitos recursos, eis que a nova versão do NetBeans veio com suporte a RESTful, e resolvi fazer alguns testes, inicialmente iria usar o KXML, e transmitir XML usando RESTful, a listagem eu consegui pegar com a ajuda do jLDAP, uma biblioteca do novell para ajudar a comunicar o java com o LDAP, a biblioteca é bem simples de se usar, e achei ela muito interessante.
Bah, eu não tava afim de usar a biblioteca de parser de XML, não funcionava como eu gostaria, e era bem limita, eis que me surge uma idéia de usar JSON, o Java Script Object Notation, que é um formato de arquivo leve parecido com o YAML, mais para minha felicidade, havia bibliotecas para Java e JME para JSON. Maravilha, e ainda por cima o RESTful do Java tem suporte a compoartilhar aquivos JSON.
O GET novamente funcionou perfeitamente, mas e o PUT? não havia jeito de funcionar, e o metodo HTTPConnection do JME suporta somente o GET e POST. Como resolver isso?
Pesquisando na net axei o seguinte post, que falava para simular o PUT como o Rails faz, porém não obtive sucesso dessa maneira, o jeito que encontrei foi o de usar um metodo POST, que consome um JSON e produz um text/plain, seguindo as definições do POST ele precisa retornar algo, vejam o código abaixo:


    @POST
    @Produces("application/json")
    @Consumes("text/plain")
    public String postJson(String content){
        try {
            JSONObject obj = new JSONObject(content);
            Person person = new PersonApacheDs().fromJSON(obj);
            dao.save(person);
        } catch (LDAPException ex) {
            ex.printStackTrace();
            return ex.getMessage();
        } catch (JSONException ex) {
            ex.printStackTrace();
            return ex.getMessage();
        }
        return "OK";
    }

existem algumas classes ai que são do meu projeto é não vou explica-las agora :). Desse modo consegui criar um serviço post que funcione para inserir dados, esse não é o metodo certo, o ideal seria usar o PUT, ainda vou fazer alguns testes, ver bem certo como o rails trabalha com o PUT, e depois eu experimento. No exemplo do outro blog, acima, ele mandava passar a data na URL, agora imagine passar um arquivo JSON na URL? Lógico que não foi aceito, por isso resolvi usar o POST. E para se comunicar é simples, primeiramente você usa um OutputStream para transmitir seus dados.


HttpConnection con = (HttpConnection) Connector.open(url, Connector.READ_WRITE);
con.setRequestMethod(HttpConnection.POST);
DataOutputStream dos = con.openDataOutputStream();
String json = obj.toString();
byte[] b = json.getBytes();
for (int i = 0; i < json.length(); i++) {
  dos.writeByte(b[i]);
}
dos.flush();

obj é um objeto do tipo JSONObject, que cria o objeto no formato JSON, e para ler vc cria um InputStream atravez da conexão, e pronto, você se comunica perfeitamente com um Serviço REST, meu próximo teste é tentar comunicar com o Rails, que pra quem não sabe utiliza o REST por padrão em todas as paginas.

Isso ai galera, espero que gostem, qualquer dúvida, ou se alguem conseguiu usar o PUT deixem um comentario ou me mandem por e-mail.

att

Testando Seu Código Java com Ruby

2009-01-23T09:58:00.000-08:00

Galera essa foi muito boa, eu procurando sobre usar o BDD em Java, algo parecido com o RSpec, que gosto tanto, e me familiarizei fácil usando no Rails. Achei um que pareceu interessante o JBehave, porém parecia mais com os Stories do RSpec, é não com os Spec, que era justamente o que eu queria, também encontrei um tal de JDave, mas ainda é um projeto embrionário, e resolvi procurar se havia uma versão do RSpec para Java, eis que caio no Blog do Ola Bini, um dos Team Leaders do JRuby, e ele mostra usando o RSpec com Java usando JRuby. Não era bem isso que queria, mas mesmo assim, resolvi experimentar, nunca mexi muito com o JRuby, já brinquei com Java e Ruby separados mas não nessa versão, usando recurso das duas linguagens juntas. Então lá fui eu copiar o exemplo do Ola Bini, e para minha surpresa funcionou muito bem, melhor do que eu esperava. Então pequei um código e comecei a testar para ver se funcionava com minhas entidades, testar um programa escrito em puro Java, em outras palavras usar as classes do Projeto e as do Ruby juntas.

Então comecei a luta para o JRuby reconhecer minhas classes, e após algumas tentativas frustradas, que incluíam adicionar o jar do Projeto no classpath, não funcionou. Estava pronto para estudar o JDave ou o JBehave, quando recorri ao senhor supremo da internet, o Google. Encontrei uma wiki sobre JRuby, e lá tinha um código relativamente ridículo, que eles diziam que adicionava a biblioteca ao JRuby. Vejam o código simples:


require "caminho/para/arquivo.jar"
module Models
 include_package "pacote/suppacote"
end

Um Module em ruby, é quase uma classe, ele é um complemento para uma classe, todo o código de um module incorporado a uma classe pode ser usado, sem restrição (ou talvez haja e eu não sei, não estudei muito essa parte.). Esse module só vai simplificar nosso trabalho, ao invés de fazer a chamada usando o padrão do JRuby que é de:


pacote.subpacote.Classe

Chamamos direto pelo estilo Ruby de Models::Classe, pode parecer poca coisa mais se você for seguir as convenções da Sun da um caminho grande até a classe.

Agora sim podemos criar nossos testes com o JRuby usando projetos Java. Vocês podem ver o exemplo do Ola Bini, e testar suas classe com o RSpec, caso não saiba ainda utilizar o RSpec, é uma chance de aprender. Para você usar na sua classe de Teste, tem que adicionar também no início do arquivo o require do seu module como, por exemplo:


require "caminho/para/models.rb"

Assim você pode usar qualquer classe do seu Projeto.jar sem problemas e testa-las usando RSpec. Pra que sofrer com JUnit?

Logo logo sai um artigo sobre MVC em PHP a pedido do meu amigo Renato, aguardem.

[]'s

ActsAsPoll – meu primeiro plugin para Rails

2009-01-11T17:31:00.000-08:00

Galera é com muita felicidade que comunico a todos que acabei de publicar no github, meu primeiro plugin, o ActsAsPoll, ele está bem simples, e provavelmente não está bem escrito, por isso ele esta disponivel para quem quiser ajudar no desenvolvimento do mesmo.

O que ele faz?
Esse plugin cria enquetes para um site em Rails, contendo a votação, e uma tela de resultado usando AJAX.

Como se usa?

Para utiliza-lo faça o download do github usando o comando


script/plugin install git://github.com/fellix/acts_as_poll.git

assim está instalado o plugin na sua aplicação, para utilizado você precisará gerar os arquivos principais utilizando o gerador poll, bem simples de se criar basta utilizar o comando:


script/generate poll poll

o primerio parametro e o generator poll que vem junto com o plugin, e o segundo argumento e o nome que será utilizado por migrações, models, controllers, etc. Executando esse comando serão criados alguns arquivos:

2 migrações, uma para a classe Poll, e outra para a classe PollOption

2 models, cada um correspondente a cada migração

1 controller, que vai gerenciar a votação via AJAX

2 partials, na pasta shared, que se não existir será criada. Uma delas monta o formulário de votação, e o outro mostra o resultado na tela.

E por ultimo 1 helper na pasta app/helpers, PollHelper, que conterá um metodo de ajuda que renderizará o partial que monta o formulário de votação.

Por enquanto o plugin não contem a parte de administração e cadastro de enquetes, mas está nos planos, caso alguém queira ajudar, essa é a hora :).
Com esse material você já pode usar a enquete, como citei anteriormente ele usa AJAX, certifique-se que no seu application.html.erb possui a tag


javascript_include_tag :defaults

e em alguma view que você queira mostrar a enquete pasta chamar o metodo helper poller e passar como parametro o argumento uma variavel do tipo Poll, e ele montará um formulário para votação.
Também é possível utilizar os metodos do ActiveRecord como por exemplo:


poller(Poll.find(1))

assim teria montada a enquete com o ID 1 no sua página. Inicialmente está bem simples, pretendo melhorar mais tarde, a ideia principal é deixa-lo simples, ainda há diversas ideias a serem colocadas no projeto, como por exemplo um gerador randomico, que pegaria uma enquete randomica a cada request, essa pode ser para um futuro update.

Utilizando restful_authorization e restful_authentication

2009-01-08T01:19:00.000-08:00

Esse tema estava no rails-br, e tinha um comentario de que faltavam documentos em português explicando o uso desses dois excelentes plugin para rails.

O que são e o que fazem?
o restful_authentication é um plugin que faz o login de um usuário de acordo com o uma tabela no banco.
e o restful_authorization é um plugin que funciona com o authentication, ele ministra as regras de authenticação de um usuário, as permissões de acesso.

Instalando
Você não precisa do authorization caso deseje somente um login.
para instalar vamos instalar apartir do github, faça o dowload do git, para o seu sistema operacional, como uso Ubuntu, para quem usa também basta utilizar

sudo apt-get install git-core

agora basta criar uma aplicação em rails, levando em consideração que já deve ter o ruby, rails e git instalados.

rails teste

agora vamos instalar nossos plugins, quando se instala um plugin do github, ele cria um repositorio git, onde vc pode atualizar seu plugin sem problemas, vamos ao que insteressa, instalando os plugins

script/plugin install git://github.com/technoweenie/restful-authentication.git

script/plugin install git://github.com/jbarket/restful-authorization.git

Na pasta teste/vendor/plugins, foram adicionadas duas pastas os nossos queridos plugins.

Agora a unica coisa que precisamos é chamar os respectivos generators, no restful-atuthorization o README esta com problemas, pois o generator dele esta com nome diferente, apenas um pequeno detalhe.

vamos criar então nosso model de autenticação

script/generate authenticated user sessions

explicando detalhadamente esse comando, estamos gerando um model chamado user, e um controller chamado sessions, o model user, vai ser nosso modelo em tabela para fazer o login, e o controller sessions, vai ser o responsavel pelos logins e logouts.

Apos rodar o generator ele adiciona algumas rotas ao seu routes.rb


map.logout '/logout', :controller => 'sessions', :action => 'destroy'
map.login '/login', :controller => 'sessions', :action => 'new'
map.register '/register', :controller => 'users', :action => 'create'
map.signup '/signup', :controller => 'users', :action => 'new'

você pode usar logout_path nos controllers, logout_url nas views etc.

para utilizar em algum controller as validações vc tem que adicionar um include no seu controller


 include AuthenticatedSystem

Após fazer fazer isso vc pode usar self.current_user que vai lhe retornar o usuário logado atualmente.

para abrir a tela de registro de usuário utilize localhost:3000/singup e pode se registrar e criar uma conta, e em localhost:3000/login

tem um metodo que ajuda muito é o logged_in?, pode ser usado para verificar se um usuário está logado. por exemplo em um before_filter em um controler, ou em uma view para verificar se o usuário esta logado.

Utilizando o Restful-Authorization

O restful-authorizaiton, esta com um problema no README, pois o generator esta com nome diferente, mas nada que va estragar seu sono.
Para gerar as autorizações precisamos de alguns parametros


script/generate authorized role user

São dois simples parametros que devemos utilizar, um deles é o novo modelo, o role, que vai manter as regras da aplicação, é um model bem simples. O segundo parametro é o model que pertence ao restful-authentication, que nós criamos acima.

Após rodar o comando acima, se abrirmos nossa classe user, veremos que alguns detalhes foram adicionados nela


  has_and_belongs_to_many :roles

  

  # has_role? simply needs to return true or false whether a user has a role or not.  

  # It may be a good idea to have "admin" roles return true always

  def has_role?(role_in_question)

    @roles_list ||= self.roles.collect(&:name).collect(&:downcase)

    return true if @roles_list.include?("admin")

    (@roles_list.include?(role_in_question.downcase.to_s))

  end

um novo metodo (has_role?) foi criado na classe e podemos utilizado para os usuário, ele verifica se o usuário possui alguma role, percebem a detalhe, já tem uma validação caso a role seja admin, que por padrão ira permitir tudo ao usuario.

Em qualquer lugar da apliçao que você possa chamar o self.current_user (veja mais acima), também poderá chamar o metodo has_role?

Ex:
self.current_user.has_role?("financeiro")

retornará true se o usuário atual tem a regra financeiro.

Essa segunda parte, eu nunca testei, mas segundo README no github do restful-authorization você pode deixar ele mesmo filtrar pelas regras adicionando em algum controle o comando:


authorized_role :financeiro

e assim ele vai validar se o usuário possui a role determinada no controller.

Muito util e simples.
Espero que tenha ajudado

Até a próxima

[]'s

Rails e Merb

2008-12-26T01:55:00.000-08:00

Essa guerra começou a pouco tempo e já terminou, e pra mim isso não é um bom sinal. Como alguns que participam da comunidade de Ruby, sabem que o Merb é outro framework para desenvolvimento web, eu ainda não tive tempo de brincar com ele, e gostaria de tirar um tempo logo para ver seu funcionamento. Porém ao chegar hoje de manhã, me deparo com a principal noticia da comunidade, o fim da guerra de Rails X Merb, a união das duas equipes para criar um só framework.

Porém ao meu ver isso não é uma boa coisa, a Guerra fria entre esses dois frameworks poderia trazer muito mais recursos e evolução para a comunidade Ruby, com essa união, finda-se a guerra, e o Rails continua absoluto. Não a concorrentes ou alguem com quem disputar espaço, então pra que correr? Pra que melhorar de forma desenfreada? Acredito que se essa fusão esperasse mais teríamos frameworks bem melhores,e quem sabe uma opção diferente ao Rails. Muita gente pode me criticar por essa opnião, não estou dizendo que a fusão é ruim, mas poderia levar mais algum tempo. A guerra fria entre EUA X URSS, trouxe toda a evolução que temos hoje, foi um grande passo para a humanidade, e acredito que se a guerra do Ruby para Web continuasse quem sabe os frameworks não melhorariam bem mais.

Detalhes

Akita on Rails

Nome do Jogo

Yehuda Katz (Merb Core)

[Tradução] Se Lingagues de Programação Fossem Religiões

2008-12-19T09:11:00.000-08:00

Achei esse texto muito interessante e resolvi traduzir e posta-lo aqui.
Podem confirir o Original clicando Aqui

"Se linguagens de programação fossem religiões"
(Inspirado por "Se linguagens de programação fossem carros")

C seria o Judaismo - é antiga e restritiva, mas o mundo está familiarizado com suas leis e respeita-os. Você não pode ser converter a ele - ou você começa do inicio, ou você irá achar que é tudo insano. Além disso, quando as coisas dão errado, muitas pessoas estão dispostas a culpar os problemas do mundo por isso.

Java seria o Cristianismo Fundametalista - É teoricamente baseado no C, mas ele foge de muitas das velhas leis que ele não sente de todo originais. Em vez disso, adiciona suas proprias regras rigidas, assim seus seguidores se sentirão superiores ao original. Não somente estão certos de que essa é a melhor linguagem do mundo, como estão prontos para queimar quem os desagradar.

PHP seria como o Cristianismo não praticante - Luta com Java pelo mercado da web. Tem vários conceitos de C e Java, mas apenas aqueles que realmente gosta. Não é coerente como as outras linguagens, mas pelo menos leh deixa muita mais livre e ostensivamente mantém a essencia da idéia. Além disso, todo o conceito do "goto hell" (vai para o inferno) foi abandonado.

C++ seria como o Islamismo - Pegou C e não só manteve todas as suas leis como adicionou um novo conjunto de leis no topo dessas. É tão versatil que pode ser usado na criação de qualquer coisa, de grandes atrocidades a lindos trabalhos de arte. Seus seguidores estão convictos que essa é a ultima linguagem universal, e ficam irritados com quem discordar deles. Além disso, se você insultar eles ou seu criador, você provavelmente será ameaçado de morte pelos seguidores mais radicais.

C# é como os Mormons - A primeira vista, é como o Java, mas ao olhar mais de perto, você verá que é controlada por somente uma corporação ( que muitos seguidores do Java dizem ser malvada), e alguns conceitos teologicos são levemente diferentes. Você suspeitaria que ela provavelmente é legal, se você não fosse discriminado por todos os seguidores de Java por seguir ele.

Lisp é como o Budismo - Ele não tem sintaxe, não tem centralização de dogmas, e não possuem santos. O universo inteiro está ai ao seu alcançe - só se você estiver esclarecido o suficiente para pega-lo. Alguns dizem que não é uma linguagem, outros dizem que é a unica linguagem que faz sentido.

Haskell é como o Taoismo - Ele é tão diferente das outras linguagens que muitas pessoas não entendem como alguem produz algo util com isso. Seus seguidores acreditam que esse é o caminho correto para a sabedoria, mas essa sabedoria está além do alcançe da maioria dos mortais.

Erlang seria como o Hinduismo - Essa é outra estranha linguagem que quem olha não consegue ve-la ser util, mas diferente da maioria das linguagens modernas, foi construida no conceito de multiplos e simultaneos santos.

Perl é como o Voodoo - Uma incompreensivel seria de encatamentos de arcanos que envolve sangue de cabras e corrompe sua alma permanentemente. Frequentemente usada quando seu chefe quer uma tarefa urgente para as 21hrs de sexta.

Lua seria como Wicca - Uma linguagem panteísta que pode facilmente ser adaptada para diferentes culturas ou locais. Seu código é muito liberal, e permite o uso de técnicas que podem ser descritas como mágicas pelas mais tradicionais linguagens. Tem uma estranha ligação com a lua.

Ruby seria como o Novo paganismo - Uma mistura de diferentes linguagens e ideias que foi socado dentro de algo conhecido como linguagem. Seus adeptos estão crescendo rapidamente, com isso muitas pessoas olham para ele com suspeitas, são normalmente pessoas bem intencionadas sem intenção de prejudicar ninguém.

Python seria como o Humanismo - Simples, sem restrições, e tudo que você precisa para segui-lo é o senso comum. Muitos dos seguidores afirmam-se livres dos encargos impostos por outras linguagens, e que redescobriram o prazer de programar. Há quem diga que é somente uma forma de pseudo-código.

COBOL é como o Antigo Paganismo - Teve um tempo que comandou uma vasta região e foi muito importante, mas nos dias de hoje está praticamente morto, para o bem de todos nós. Emboram muitos ainda estejam marcados por seus rituais, há muitos que insistem em mante-lo vivo.

APL seria como Cientologia - Existem muitas pessoas que clamam para segui-lo, mas você sempre suspeitará que é uma grande e elaborada pirraça que irá fugir do seu controle.

LOLCODE seria como Pastafarianism(WTF!?!?) - Uma exoterica, nascida na internet e que ninguem leva a serio, ignorando todos os esforços para desenvolve-la e dissemina-la.

Visual Basic seria como o Satanismo - Exceto que você realmente não precisa vender sua alma para ser um satanista.

Desculpem-me pelos erros, se alguma coisa ficou traduzida errada me corrigam.

[]'s

RIA - O Futuro da Web

2008-12-16T06:32:00.000-08:00

Estive a um bom tempo pensando em escrever algo sobre isso. O Futuro da Web maketeiramente conhecida como Web 2.0 e o RIA seria algo como a Web 3.0. Mas que droga seria essa? o que exatamente seria esse tal de RIA.

RIA é uma sigla para Rich Internet Application, é um termo bem visado por muitas empresas e apadrinhado principalmente pelo Google, o GMail é um grande exemplo de uma Aplicação Rica. Na verdade o RIA nada mais é que uma montoeira de coisa velha em uma sigla nova. RIA usa muito do AJAX, JavaScript.

AJAX, não é o multi uso não, e tem diversas definições no Google sobre o AJAX, não vou entrar em detalhes aqui. O uso de JavaScript, menosprezado durante muito tempo, agora tudo gira em torno dessa linguagem. Nada mais natural pois todos os desenvolvedores procuram dar mais interatividade entre o cliente e sua página e o JavaScript é suportado por todos os browsers, lógico que alguns trabalham diferente com ele (IE), até o Acrobat Reader suporta JavaScript, nunca testei, mas ouvi dizer.

O que me levou a escrever sobre isso foi olhando no meu iGoogle algumas noticias e de caro vejo duas que me chamaram a atenção:
Sun lança o JavaFX 1.0 - Rich Internet Applications (RIA) para o Java
Red Hat e Google em parceria para desenvolvimento de RIAs
JavaFX pra quem é da comunidade Java já conhece, é uma promessa do Java, digamos uma versão WPF open source, pra quem não conhece WPF é da Microsoft, trabalha com Silverlight,e server tanto para Desktop quanto para Web, e é voltada para Designers, não para desenvolvedores. JavaFX é a mesma coisa, mas a diferença é que WPF é visual, já JavaFX é uma linguagem de Scripts, muito simples, que eu particularmente, não gostei :P.

Já parceria da Red Hat com o Google é para o fortalecimento do GWT, Google Web Toolkit, para um suporte ao JBoss, o GWT eu particularmente gosto muito dele, mas o problema é que assim como eu muita gente tem a opnião errada dele, assim como eu tinha. o GWT é um Framework que converte código Java em JavaScript, você pode adapta-lo para qualquer linguagem pois a saida é html, js e css. O Objetivo do GWT é criar somente a aplicação, o core, a parte principal, o restante do site vc faz na linguagem que quiser. o GWT monta um interface parecida com a do GMail, e é muito divertido brincar com ele.

Na minha singela opnião RIA é o futuro, acredito que devemos nos dedicar um pouco a essa area que muitas vezes é deixada de lado, mas acredito que quem não apostar em interfaces mais ricas, com maior interatividade com o usuario irá perder espaço, a maioria dos frameworks que estão surgindo ou evoluindo facilitam o AJAX nas paginas, e esse é o caminho (Ruby on Rails é um desses frameworks com o esquema de templates deles você pode criar arquivos .rjs que se transformam em paginas utilizando AJAX, não vou me deter sobre isso não vocês podem achar muito disso e bem explicado por ai), aprender JavaScript pode se tornar fundamental, então? Mãos a obra

Dialog Box em JavaScript

2008-12-11T02:19:00.000-08:00

Vasculhando pela net procurando um esquema de Dialog Box em JavaScript, para criar alguns efeitos mais iterativos, encontrei nessa página
http://www.leigeber.com/2008/04/custom-javascript-dialog-boxes/
um esquema de Dialog Box bem simples e funcional, testando e aprovado, é bem simples de editar, o código não é dificil de se alterar, pois está bem escrito.

Ele funciona com um serie de divs que vc pode criar ou deixar ele criar dinamicamente, lógico que quando ele cria dinamicamente as box elas so contem mensagens de texto. Mas você pode editar isso. Basta criar os divs.

O Arquivo (dialog_box.js) vem escrito por padrão com somente duas opções, ou você deixa ele criar tudo, ou você cria todos os divs, que por padrão devem ter os ids
'dialog', 'dialog-header', 'dialog-title', 'dialog-close', 'dialog-content', 'dialog-mask'.

Como podem ver são bastantinhos divs a serem criados, e eu como sou meio vadio para essas coisas prefiro so criar um, o 'dialog-content', que é o dialog que contem o conteudo da janela.

uma simples edição no JavaScript pode resolver isso.
Na função
function showDialog

deve se procurar pela linha
if(!document.getElementById('dialog')) {

e aonde procurar dentro deste if uma definição do conteudo
dialogcontent = document.createElement('div');
antes dessa linha basta criar uma condição para ele não criar o elemento e sim utilizar o div que criariamos na pagina, lembrando que o div alem do id=content-dialog deve ter style="visibily: hidden".
Adicionamos então o seguinte código

if(! document.getElementById('div-content')){
//Aqui vai o código que ja tinha no arquivo
dialogcontent = docum...
}else{
dialogcontent = document.getElementById('div-content');
}

e por ultimo mas não menos importante basta comentar a seguinte linha
dialogcontent.innerHTML = message;

agora sim, a função showDialog se encontrar um div com o id= div-content, vai pegar esse div e todo seu conteudo e mostrar na janela do tipo que foi escolhido.

Caso não esteja claro, podem perguntar nos comentarios, qualquer coisa disponibilizo o arquivo editado para download.

[]'s
até a proxima

Seguindo Padrões

2008-12-03T08:59:00.000-08:00

Uma coisa não tão comum no desenvolvimento de software, normalmente de algumas empresas, é a falta de padronização, até por que as maiorias das empresas de desenvolvimento começam do nada com um pequeno software e depois com o aumento de clientes acabam tendo que contratar mais pessoas para trabalhar, e cada um tem seu estilo, muitas vezes não há um padrão a ser seguido, eis que surge o que vou falar agora.

O que me questiono é que normalmente um código sem padronização acaba saindo estranho, códigos repetitivos sem necessidade, onde tudo poderia ser mais fácil e mais rápido a falta de Padrões de Projeto, Pra que ficar abrindo conexões com o banco sem necessidade? Mas o que mais me surpreende é a falta de Controle de Versão, como se não tivéssemos opções suficientes (Git, CVS, SVN, Mercurial, etc), muitos desenvolvedores nem saber o que é um Controle de Versão nem pra que serve.
Eu sempre gostei do CVS e quando conheci o Git gostei muito dele, ele foi feito por nada mais nada menos que Linus Torvalds para controlar a versão do kernel do Linux, mas não estou aqui para falar de cada um deles nem de como funcionam vocês podem achar isso no nosso querido amigo Google. A grande vantagem de se usar o versionamento é que você sempre saberá quem fez aquela cagada no código.

Por exemplo, seu código funciona redondinho e tudo certo, porém alguém da sua equipe atualizou, mas não testou as outras partes, você atualiza a versão original, e logo depois um cliente liga dizendo que tal tela não esta mais funcionando, e ao averiguar você percebe que aquele código a mais estragou outra parte do sistema, e agora como voltar? Dificilmente quem modificou vai lembrar-se de onde modificou, e o que modificou. Com o controle de versão você pode saber exatamente o que foi modificado e aonde foi, assim se torna mais fácil de concertar o problema (gambiarrizar ou não). Só por esse motivo já valeria a pena, sem contar em branches e tags onde pode ser dividida a codificação sem interferir no código principal do projeto, só depois de analisado e testado é feito o merge (mesclar). E garanto, vale muito a pena usar Controle de Versão.

O que esta esperando? Comece agora!

Por que Não PHP?

2008-11-25T04:03:00.001-08:00

Estive conversando com um amigo fã de PHP e resolvi postar aqui o porquê não curto muito PHP, apesar de gostar da linguagem e de saber programar, prefiro outras linguagens como Java e RoR.

Meu problema com PHP é a salada de frutas que ele faz no código, o uso abusivo de tags no meio de paginas HTML tornando o código muito estranho e de difícil manutenção. Alguém ai já olhou algum projeto Open Source em PHP estilo o PHPMyAdmin ou o oCommon? Chega de assustar a lambança que é feita no código, é muita mistura. Existem frameworks que auxiliam isso como é o caso do Zend Framework e do Symfony, mas normalmente quem usa PHP procura um local de hospedagem gratuita aonde hospedar seus códigos, e dificilmente essas hospedagens suportam esses frameworks.

Eu procurei um pouco de tudo para tornar meus códigos em PHP melhores, ate tentei utilizar conceitos de OO do Java, porém não obtive sucesso. Foi melhor utilizar o estilo de OO do PHP, agradeço até hoje pela PHP 5, pois ele trouxe muitos conceitos de OO para dentro do PHP. Algumas functions que facilitam o desenvolvimento, como é o caso de métodos __construct utilizado por construtores e os métodos (the Best of), __set e __get , que são usados para criar getters e setters genéricos. Mesmo com essas funções experimente aplicar os padrões Singleton e MVC no php, o singleton e suportado com ajuda de algumas outras ferramentas, mas mesmo assim não é tão simples. Já o MVC é uma luta, realmente dura.

PHP X MVC

Uma classe que me facilita um monte o trabalho é a classe do Rael Cunha disponível em http://www.raelcunha.com/template.php, sei que muita gente gosta do Smarty, mas o Smarty e meio pesado para projetos pequenos. E eu gosto de coisas simples. Mas mesmo assim o código continua horrível, então eu pra simplificar criei uma classe que faz a consulta no banco e me retorna arrays e arrays de arrays, mas mesmo assim o código continua feio. Por mais que você lute parece que cada vez fica pior. Veja por exemplo minha classe de conexão chamada banco:

$con = new Banco();
$con->conectar();
$array = $con->find("SELECT * FROM tabela");
foreach($array as $a){
...
}
$con->fechar();

Bem simples o exemplo acima ele só mostra o simples funcionamento da classe, até pensei em criar um esquema de Models e DAOs que acessam a base direto por SQL, porém não obtive muito sucesso. Pois os códigos estavam se tornando grandes e praticamente inutilizáveis, e achei essa solução ate mais legível inicialmente, porém tenho um pequeno projeto, um jogo web based (www.championti.web44.net), que está ficando muito grande e como fiquei um bom tempo sem mexer, até em função do meu TCC, e quando fui olhar os códigos já nem sabia mais pra que tanta coisa. Se fosse rever esse código até para utilizar DRY, teria que reescrever tudo de novo, sim eu já reescrevi o código para adicionar os templates, e digo, não foi fácil. Agora com um problema desses vou modificar um sistema inteiro, o de corridas do jogo, porém estou tendo muitas dificuldades em utilizar o código, portanto antes de reescrever tudo novamente em PHP, estou pensando seriamente em reescrever o jogo com RoR, ainda vou fazer alguns testes, mas qualquer coisa eu comunico-os sobre o desenvolvimento do jogo.

Java Record – um jeito diferente de ORM

2008-11-21T06:54:00.000-08:00

O Java Record surgiu com uma idéia de evitar as dificuldades de se mapear classe por classe usando Hibernate, seja com os .hbm.xml ou com Annotations, lógico que a segunda alternativa, é a mais rápida, porem eu como um verdadeiro programador a moda antiga, gosta de configurações, prefiro escrever 900 xml do que usar annotations. Lógico que isso não quer dizer não use annotations, eu as usei, e confesso que achei muito eficiente. Mas não era isso que eu queria, dava muito trabalho, eu como costumo seguir as regras da normalização, acabo gerando diversos models para simples cadastros, e era trabalhoso de mais configurar todos os XML.

Eis que me aventuro no mundo do Ruby on Rails, já havia tentado a muito tempo atrás, mas não havia gostado muito, hoje com mais conhecimento, consegui ver vantagens na linguagem, e lógico comecei do jeito certo, pelo Ruby, na outra vez me taquei direto no Rails, que não aconselho a ninguém não foi uma experiência muito agradável, era basicamente CTRL C + CTRL V. E pesquisando mais a fundo sobre o funcionamento do Active Record (O ORM do Rails), percebi que ele era simples pois, perguntava para o banco quais seus atributos, na hora me veio na cabeça ResultSetMetaData, que faz a mesma coisa, retorna as colunas de uma tabela, e pensei que poderia usar isso para facilitar o desenvolvimento dos meus models nas brincadeiras que fazia.

Então comecei a escrever o JavaRecord, meu objetivo era agilizar o trabalho, porém eu precisaria de um arquivo de configuração, para pelo menos me indicar aonde conectar, eis que surgiu o config.yml. Mas por que YAML? YAML é um formato de texto simples e fácil de ser lido, é rápido e facilmente processado pela aplicação, e é muito fácil de ser lido, sem todas aquelas frescuras do XML. Assim comentei com alguns colegas meu da faculdade, e acharam a idéia interessante, resolvi ver o que o pessoal o Java.net achava da minha idéia, e ela foi aprovada no Java.net, então começou um projeto Open Source para Java, atualmente na versão 0.1.1 o projeto é bem fácil de ser utilizado em bancos MySQL, porém um teste com o Oracle me decepcionou, como eu pude esquecer das seqüências? Agora estou em um dilema como vou adicionar as seqüências do Oracle? Não quero adicionar mais configurações, e estou até pensando em criar um esquema de dialetos. O próximo passo é criar automaticamente os vínculos com chaves primarias, evitando assim mais uma configuração.

Para quem quiser ver um exemplo funcional clique aqui e veja um PDF mostrando o funcionamento do JavaRecord. E para fazer o download do JavaRecord com dependências acesse o sourceforge.net.

Spree-pagseguro-carrinho-proprio Atualizado

2008-11-20T02:54:00.000-08:00

Adicionei algumas alterações no spree-pagseguro-carrinho-proprio no Github, lembrando que esse é um projeto para Ruby on Rails, mas precisamente uma extensão a um projeto Open Source o Spree.

O Spree é um projeto de e-commerce para Ruby on Rails, pode servir como base para qualquer aplicação, porém ele possuia somente vinculos com meios de pagamento internacional, e surgiu a ideia de criar um extension para o Spree utilizando algum meio de pagamento brasileiro, como é o caso dessa, ela utiliza o carrinho do Spree para se vincular com o Pagseguro.

Nesse commit adicionei o RSpec de teste da view que altera para fazer o vinculo, para utilizar você so precisa cadastrar algum e-mail seu no pagseguro e adicionar no codigo fonte da extension, prometo em breve melhorar isso, colocar quem sabe em um YAML, vou pensar sobre isso para facilitar mais, voltando a falar do commit também fiz algumas alteraçõe spara seguir as convensões do Spree de extension.

Para mais detalhes acessem o site do Spree

E vejam o projeto no meu GitHub

Se quiserem dar uma olhada, ou sujestões fiquem a vontade

-----------------------------------------------------------------------------------------------

Aproveitando esse post vou falar um pouco sobre minha aventura com o RSpec.

Eu como desenvolvedor Java nunca fui fã de usar testes, em Java debugamos, apesar de existirem ferramentas boas para criar testes, não é muito comum criar suites de testes.

Então começei a participar do Spree, com essa ideia de integração com o Pagseguro, ai fiquei sabendo que teria que criar testes RSpec para o projeto pois um projeto Rails sem testes não é bem visto. Então la fui eu pesquisar sobre o RSpec, e uma coisa me chamou a atenção, o RSpec é muito famoso na comunidade, e muito utilizado, porém ele é muito mal documentado, ou eu que não vi direito, porém você quase não ve exemplos no site.

Ainda bem que existem screencasts, o nofxx tem uma que introduz ao RSpec, que foi muito util, aprendi como funciona o RSpec, pois estava complicado de entender.

Passei a fazer alguns teste, e pronto, já sentia que estava dominando o RSpec, grande ilusão.

Nessa extension para Spree, eu so tenho que testar uma view, uma única view, qual será a diferença. Pois é, me ferrei. E realmente não tava evoluindo os testes, não conseguia rodar, davam erros em objetos da view, e por mais que eu criasse mock eles continuavam, só depois que percebi que faltavam os helpers do Spree, então adicionei os que são utilizados na view, e novamente mas problemas com models, porém dinha um erro que eu tinha concertado, errrr digamos com gambiarra;

A view dava um erro pois o Spree usa o Resource_Controller, e ele dizia que o metodo ou variavel object_url é indefinido, então eu muito esperto escrevi um metodo para solucionar isso, e o erro passou, mas um teste não pode fazer isso não é, então recorri ao Google Groups do rails-br, e lá demorou um pouco mais me falar de um tal de scaffold_resource que gera os testes do RSpec, pra mim dar uma olhada, e realmente foi uma linha de código para solucionar isso:

template.should_receive(:object_url).twice.and_return(order_path(@order))

E pronto o erro foi resolvido, depois outro erro, dessa vez recorri ao rubyonbr.org, e o nofxx me respondeu, esse erro era meio estranho

expected :line_items with (any args) once, but received it 4 times

era como se ele dissesse que usei algo a mais, muito estranho. E realmente eu tinha que disponibilizar o :line_item, exactly(4).times, e pronto foi só esse ajuste e o teste funcionou.

Mas na verdade o que me deixou assustado foi a falta de aplicações exemplos no site do RSpec, que ajudariam muito quem esta começando, ainda tenho que fazer muitos testes pra pegar bem o RSpec, mas vamos assim como esta.

[]'s

Mais um blog?

2008-11-19T03:20:00.000-08:00

Realmente esse é mais um blog sobre desenvolvimento por isso esse nome. Deixe eu me apresentar, meu nome é Rafael Guzi Felix da Silva, também conhecido como Felix, estou atualmente na 8ª fase do curso de Ciência da Computação na UNOESC, e meu real interesse nesse blog é dividir meus conhecimentos com quem assim como é apaixonado por desenvolvimento. Atualmente estou brincando bastante com Ruby on Rails, mas esse blog também vai falar de outras linguages.

Também vou aproveitar para comentar do meu ORM o Java Record, que é baseado no Active Record do Rails, mas para Java, visando a facilidade do desenvolvimento, e a agilidade, sem configurações e sem todos aqueles XML para fazer o relacionamento.

Para mais informações sobre o Java record acesse o site hospedado no java.net, os fontes se encontram no sourceforge.net, mas pelo site (se alguem ai quiser contribuir em construir um site melhor eu ficaria feliz ;) ) da para ter uma noção de como se usa o Java Record, atualmente versão 0.1.1 pois foi adicionado o relacionamento de um para muitos.

Estou ajudando também a criar algumas integrações para o Spree que é um projeto de e-commerce em Ruby on Rails. Alguns projetos que ajudo vocês podem encotrar no GitHub.