JMS e JRuby é com o JSparrow!

Quem já trabalhou com JMS sabe que esta API não é muito trivial para trabalhar com mensageria, mas com Java por mais que utilize um framework para abstrair a complexidade, nós sempre chegaremos bem próximos do JMS e conseqüentemente deixaremos nosso códigos complexos!

Bem com JRuby isso já não é um problema, existe um projeto que abstrai (onde é possível) a complexidade do JMS e torna nosso trabalho bem mais simples e sabem o melhor? É DO BRASIL!!!

JSparrow, é um projeto hospedado no github, está em pleno desenvolvimento e tem como idealizador Leandro Silva. Na última versão a 1.1.1 o projeto ganhou, entre outras features, a possibilidade de implementação de um Listener (tanto para filas e tópicos) e isto possibilitará a conclusão deste post.

Neste tópico vamos escrever um código clássico, para quem aprendeu JMS por livros com certeza já escreveu um Chat básico para ser usado na linha de comando, então, é isso que faremos agora.

O exemplo é muito simples, vamos criar um tópico em um Application Server, no meu caso foi no Weblogic, por que? Porque eu gosto de sofrer, oras! Depois vamos nos registrar nesse tópico e criar um listener para ficar escutando-o, tudo bem simples.

Então vamos ficar assim, o pré-requisito é que você tenha um provedor JMS, no meu caso como eu disse foi o Weblogic, mas eu não o recomendo, a escolha mais simples caso você não tenha experiência é o OpenJMS, o mesmo usado nos exemplos do JSparrow.

O exemplo escrito em Java pode ser visto no site onjava.com e o nosso veremos a seguir:

Instalando a gem

gem install jsparrow

Crie um arquivo chamado chat_com_jsparrow.rb.
Adicionando a gem ao exemplo:

require 'rubygems'
require 'jsparrow'

Recebendo parâmetros de linha e parametrizando a conexão com o provider.

$NOME = ARGV[0] if ARGV[0]

JSparrow::Connection.configure do |connection|
  # adicione aqui a lib do client do seu provider
  connection.use_jms_client_jar '/Users/alan/Oracle/Middleware/wlserver_10.3/server/lib/weblogic.jar'

  # verifique as configurações do seu provider
  connection.use_jndi_properties :initial_context_factory => 'weblogic.jndi.WLInitialContextFactory',
                                 :provider_url            => 't3://localhost:7001',
                                 :security_principal      => 'weblogic',
                                 :security_credentials    => 'weblogic123'
   # o nome da factory e do topico que voce criou
  connection.enable_connection_factories :topic_connection_factory => 'ConnectionFactory'
  connection.enable_topics :chat_topic => 'MyTopic'
end

Iniciando a conexão e criando o sender para enviar as mensagens.

jms_client = JSparrow::Connection.new_client
jms_client.start
topic_sender = jms_client.topic_sender(:chat_topic)

Criando a implementação do listener.

class ChatTopicListener < JSparrow::Connection::Listener
   listen_to :topic => :chat_topic

   def on_receive_message(received_message)
      puts "#{received_message.text}"
   end
end

Registrando o listener e iniciando a “escutação” rs!

listener = JSparrow::Connection.new_listener :as => ChatTopicListener
listener.start_listening

Enviando as mensagens, começando a diversão!

texto = ""
while texto != "exit"
   print "Escreva seu texto: "
   texto = STDIN.gets.strip
   mensagem = texto
   mensagem = "#{$NOME} escreveu: #{mensagem}" if $NOME
   topic_sender.send_text_message(mensagem)
end

Finalizando.

listener.stop_listening
jms_client.stop

Fácil né? Vamos colocar para rodar!

bash$> jruby chat_com_jsparrow.rb Um_nome

E em outro terminal

bash$> jruby chat_com_jsparrow.rb Outro_nome

Escreva as mensagens e veja o resultado.

O JSparrow tem mais características interessante e avançadas, como por exemplo colocar critérios na seleção de mensagens no tópico ou em filas, então não deixe de acompanhar o projeto no github.

O código deste post pode ser encontrado no aqui, deixei o exemplo com seleção de mensagens.

Por hoje é só pessoal! Não esqueça de deixar seu comentário.

Link deste post

ssh-copy-id no Mac OS X

Eu iria escrever toda uma história explicando porque desse script, mas desisti. Só quero agradecer ao MV pela dica e o script está aí, para copiar sua chave ssh pública para um servidor e fazer acesso ssh sem ter que digitar senha do usuário.

arquivo ssh-copy-id:

#!/bin/sh

KEY="$HOME/.ssh/id_rsa.pub"

if [ ! -f $KEY ];then
  echo "private key not found at $KEY"
  echo "* please create it with "ssh-keygen -t dsa" *"
  echo "* to login to the remote host without a password, don't give the key you create with ssh-keygen a password! *"
  exit
fi

if [ -z $1 ];then
  echo "Please specify user@host.tld as the first switch to this script"
  exit
fi

echo "Putting your key on $1... "

KEYCODE=`cat $KEY`
cat $KEY | ssh $1 "cat - >> ~/.ssh/authorized_keys"

echo "done!"

Logo, para mandar sua chave para o servidor, basta:

$ ssh-copy-id usuario@endereco_ou_ip_do_servidor

Claro, você terá que digitar a senha do usuário do servidor pela última vez, se tudo funcionar…

Ah! Minha busca no google foi essa.

Filed under: tutorial Tagged: mac, ssh

Link deste post

EJB 3.0 no Weblogic e JRuby, será que rola?

Não sei se todos aqui vem aqui no blog sabem, mas atualmente trabalho como Arquiteto de Sistemas da CVC Turismo, como não é o foco do post deixarei para falar sobre minhas atividades diarias outro dia !

Bem, entre o dia 23 e 24 de fevereiro (ontem e hoje considerando o dia que escrevi esse post) fiquei ajudando em um deploy e uma preparação de uma aplicação para uma apresentação. Entre um build, um deploy, uma leitura de um log, fiquei “rascunhando uns códigos”.

O que eu queria era fazer lookup de EJB de uma aplicação centralizadora de serviços de negócio que temos lá, com JRuby!
Considerando que quando migramos de OC4J para Weblogic (essa migração ainda está rolando) tivemos muito problemas com EJB’s, achei que eu não ia conseguir fazer esse tal lookup em 1 ou 2 horas, então fiquei nos código apenas para passar o tempo.
Acabei encontrando um post que me ajudou na brincadeira. E o resultado disso eu vou mostrar a seguir:

Primeiro o código Java para a gente entender o que foi feito:

import javax.ejb.*;
import javax.naming.*;
import br.com.cvc.systur.app.*;
import java.util.Calendar;
import java.util.GregorianCalendar;
import br.com.cvc.systur.domain.pessoa.*;
import br.com.cvc.systur.app.pessoa.*;
import br.com.cvc.systur.domain.pessoa.documento.*;

public class Client {
    public static void main(String[] args) throws Exception {
         Context ic = new InitialContext();
         Object obj = ic.lookup(ServiceCatalog.CONSULTA_PESSOA.getName());

         ConsultaPessoaService cps =(ConsultaPessoaService) obj;

          for(TipoDocumento tp : cps.consultarDocumentos()){
               System.out.println(tp.getDescricao());
          }
    }
}

Aqui já temos as “particularidades” do Weblogic aparecendo, como podem nós temos um catálogo com todos os serviços, não entrarei em detalhes, mas ele serve, além de outras coisas, para obtermos o nome do bidding do objeto na arvore JNDI, entenderemos melhor no código JRuby.

Este código obtém o EJB que representa um serviço de consulta de pessoas e utilizamos a operação consultarDocumentos para obter todos os tipos de documentos que trabalhamos, simples, muito simples!

Agora vamos ao JRuby

require 'java'
include_class 'javax.naming.InitialContext'

ic = InitialContext.new
teste = ic.lookup('systur-domainsystur-domain-ejb_jarConsultaPessoaServiceBean_ConsultaPessoaService')

tipo_docs = teste.consultarDocumentos

tipo_docs.each { |tipo_doc| puts tipo_doc.descricao }

Olhe o lookup, veja o nome de ligação padrão no Weblogic, sei que não é o foco do post, mas entendeu porque temos o nosso “Catalogo”, isso porque nem vou entrar nos detalhes de como fazemos versionamento dos nosso serviços!

Esse código em JRuby, mas exatamente a mesma coisa que o código em Java, obtém o EJB e utilizamos um método e imprimimos a descrições dos tipos de documento.

Terminada toda a diversão, o trabalho da madrugada foi feito e eu estou aqui agora, cheio de idéias, entre elas melhorar nossa base de testes (que é um debito técnico nosso!) e deixa-los mais expressivos com JRuby, ou mesmo validar a saúde de nossa aplicação em produção rodando um simples script e executar testes de em produção (audacioso)!

É isso, mais uma barreira do Weblogic quebrada e mais uns 100 pontos na balança do Ruby e do JRuby!

Link deste post

[OpenSUSE] Ativando flash player no Google Chrome

Recentemente instalei o Google Chrome em meu desktop com OpenSUSE 11.2 instalado, e assim que comecei a utilizá-lo percebi que a instalação padrão do flash player não funcionava.

Verificando a estrutura de diretórios do pacote, percebi que a pasta dos plugins do Chrome não fazia referência a pasta de plugins do sistema (/usr/lib/browser-plugins/) e também não tinha nenhum plugin instalado localmente.
Desta forma fica fácil chegar-mos na solução do problema, simplesmente vamos criar um link simbólico apontando para o diretório correto:

cd /opt/google/chrome
ln -s /usr/lib/browser-plugins/ plugins

Para descobrir se está funcionando corretamente, simplesmente abra uma nova aba e navegue algum site que utilize Flash.

Link deste post

Envolvimento x Comprometimento

A famosa sátira da galinha e do porco, bastante difundida entre desenvolvedores que trabalham com tecnologias ágeis, porém, é uma lição para todas as coisas.

 

Link deste post

Criando atalhos para o MongoDB

Perdi a conta de quantas vezes tive que relembrar qual era o caminho para subir o MongoDB ou para abrir o Shell para fazer alguma pesquisa. Para simplificar configurei o PATH e criei um ALIAS no arquivo .bashrc. Seguem os passos para fazer isto rapidinho. Abra o arquivo .bashrc com sudo pelo terminal. Onde “Yourusername” [...]

Link deste post

Manipulando dados pelo shell do MongoDB

Assim como o MySql o MongoDB tem um shell para manipular dados diretamente na base, seguem os comandos (CRUD) básicos para inserir, buscar, atualizar e apagar documentos. Para inicializar o shell: /opt/mongo/bin/./mongo Se tiver algum problema com este comando então faça isto: cd /opt/mongo/bin/ ./mongo ** Neste post mostro como criar um atalho As linhas [...]

Link deste post

Métodos que retornam mais de um valor em Ruby

Nas últimas semanas, a equipe que eu trabalho estava desenvolvendo um web service onde havia a necessidade de renderizar o retorno de uma lógica de negócio em representações XML. Digo representações (no plural), pois para um retorno com sucesso a representação seria uma e para retorno com erro a representação seria outra. Por exemplo, um retorno [...]

Link deste post

Primeiro projeto Rails com MongoDB

Você que leu o post 10 minutos com Ruby e MongoDB, provavelmente ficou pensando: “Como incluo o MongoDB no meu projeto Rails?”, bem, este post vem com intuito de ajudá-lo nesta sua dúvida cruel!

Nós poderíamos criar um projeto Rails com e ir ajustando-o, mas tem um jeito mais fácil para esta tarefa, eu encontrei esses templates e ajustei um pouco para escrever esse post.

Na pratica eu retirei alguns pontos e inclui outros para simplifica-lo, mas nada que altere o objetivo principal, criar um projeto Rails com MongoDB!

O Template passo a passo

Abaixo será apresentado o template usado para criar novas aplicações Rails com MongoDB, você também poderá ver o template aqui: http://gist.github.com/307386.

Removendo arquivos desnecessários

run "rm public/index.html"
run "rm public/images/rails.png"

Colocando o nome do seu banco no MongoDB e editando o arquivo database.yml com os dados do banco

db_name = ask('Qual será o nome do seu banco no mongodb? ')

# Editando o arquivo database.yml
# Com os dados do banco
file 'config/database.yml', <<-CODE
base: &base
  adapter: mongodb
  # em tempo de execucao vamos adicionar o "-\#{Rails.env}" ao nomo do banco
  database: "#{db_name}"
# Se estiver rodando o mongodb em outro host,
#vc deveria autenticar-se
  #host: host.mongodb.com
  #username: your-username
  #password: your-password

# use as proximas linhas para colocar algo especifico a cada ambiente
development:
  <<: *base

test:
  <<: *base

production:
  <<: *base
CODE

Colocando um arquivo na inicialização do rails. Este arquivo será encarregado de conectar no banco

initializer 'database.rb', <<-CODE
include MongoMapper

db_config = YAML::load(File.read(File.join(Rails.root, "/config/database.yml")))

if db_config[Rails.env] && db_config[Rails.env]['adapter'] == 'mongodb'
  mongo = db_config[Rails.env]
  MongoMapper.connection = Mongo::Connection.new(mongo['host'] || 'localhost',
                                                 mongo['port'] || 27017,
                                                :logger => Rails.logger)
  MongoMapper.database = "\#{mongo['database']}-\#{Rails.env}"

  if mongo['username'] && mongo['password']
    MongoMapper.database.authenticate(mongo['username'], mongo['password'])
  end
end

ActionController::Base.rescue_responses['MongoMapper::DocumentNotFound'] = :not_found
CODE

Não precisamos do Active Record.

environment 'config.frameworks -= [:active_record]'

Adicionando a gem do MongoMapper

gem 'mongo_mapper'

Adicionando um Testing Helper, que adicionará o método teardown (executado no fim do teste) para todas as classes que herdam ActiveSupport::TestCase

file 'test/test_helper.rb', <<-CODE
ENV['RAILS_ENV'] = 'test'
require File.expand_path(File.dirname(__FILE__) + '/../config/environment')
require 'test_help'

class ActiveSupport::TestCase
  # Apagando todas colecoes depois de cada test case
  def teardown
    MongoMapper.database.collections.each do |coll|
      coll.remove
    end
  end

# adicionando o metodo teardown em todos test cases
  def inherited(base)
    base.define_method teardown do
      super
    end
  end
end
CODE

Finalizando o gerenciamento das gems

rake 'gems:install'
rake 'gems:unpack'
rake 'rails:freeze:gems'

Ignorando alguns arquivos no controle de versão e comitando no git

file '.gitignore', <<-FILES
.DS_Store
**/.DS_Store
log/*
tmp/*
tmp/**/*
FILES

# comitando os fontes
git :init
git :add => '.'
msg_git = ask('Escreva seu comentario no commit do git')
git :commit => "-a -m \"#{msg_git}\""

Gerando sua aplicação Rails

rails nome_da_aplicacao -m "http://gist.github.com/307386.txt"
ou
rails nome_da_aplicacao -m "caminho_do_template"

Usando o generate

Na raiz do seu projeto recém criado rode:

ruby script/generate scaffold user

Aqui tem um ponto de atenção! O model não foi criado, isto porque não temos o ActiveRecord, mas calma será tudo muito simples, não desista agora!

Criando o Model

Seremos simples para não complicar! Um simples modelo de usuário (user.rb) a seguir:

# Diferente do ActiveRecord com o MongoMapper usamos inclusão ao invés de herança
class User
  include MongoMapper::Document

  # cada atributo deve ter o nome (como um Symbol) e seu tipo
  key :nome, String
  key :email, String
  key :nickname, String

  # para utilizar os Helper do ActionView é importante sobrescrever o método "to_s"
  def to_s
    self._id
  end
end

E as migrations??? É aqui não tem migrations, nós não precisamos nem criar o banco no MongoDB, a primeira vez que rodar a aplicação e utilizar o Model, voilá! Lá estarão as coleções!

Ajustando a view do CRUD

Aqui vamos chover um pouco no molhado, mas informação nunca é demais!

index.html.erb
Como eu disse acima, na construção do Model, o helper “link_to” usa o método “to_s” para construir os links no CRUD, nosso index ficará assim:

<h1>Listando Usuários</h1>

<table>
  <tr>
	<th>Nome</th>
	<th>Email</th>
	<th>Nickname</th>
  </tr>

<% @users.each do |user| %>
  <tr>
	<td><%= user.nome%></td>
	<td><%= user.email%></td>
	<td><%= user.nickname%></td>
    <td><%= link_to 'Show', user %></td>
    <td><%= link_to 'Edit', edit_user_path(user) %></td>
    <td><%= link_to 'Destroy', user, :confirm => 'Are you sure?', :method => :delete %></td>
  </tr>
<% end %>
</table>

<br />

<%= link_to 'New user', new_user_path %>

show.html.erb
Vale a dica do “link_to” mostrada no index

<b>Nome</b>: <%= @user.nome %><br />
<b>E-mail/<b>: <%= @user.email %><br />
<b>Nickname</b>: <%= @user.nickname %><br />
<%= link_to 'Edit', edit_user_path(@user) %> |
<%= link_to 'Back', users_path %>

new.html.erb
Nada de novo!

<h1>Novo Usuário</h1>

<% form_for(@user) do |f| %>
  <%= f.error_messages %>

<table>
	<tr>
		<td><%= f.label :nome %>:</td>
		<td><%= f.text_field :nome, :size => 40 %></td>
	</tr>
	<tr>
		<td><%= f.label :email, 'E-mail' %></td>
		<td><%= f.text_field :email %></td>
	</tr>
	<tr>
		<td><%= f.label :nickname, 'Nickname' %></td>
		<td><%= f.text_field :nickname %></td>
	</tr>
</table>

  <p>
    <%= f.submit 'Create' %>
  </p>
<% end %>

<%= link_to 'Back', users_path %>

edit.html.erb
Aqui também nada de novo.

<h1>Editando usuário</h1>

<% form_for(@user) do |f| %>
  <%= f.error_messages %>

<table>
	<tr>
		<td><%= f.label :nome %>:</td>
		<td><%= f.text_field :nome, :size => 40 %></td>
	</tr>
	<tr>
		<td><%= f.label :email, 'E-mail' %></td>
		<td><%= f.text_field :email %></td>
	</tr>
	<tr>
		<td><%= f.label :nickname, 'Nickname' %></td>
		<td><%= f.text_field :nickname %></td>
	</tr>
</table>

  <p>
    <%= f.submit 'Update' %>
  </p>
<% end %>

<%= link_to 'Show', @user %> |
<%= link_to 'Back', users_path %>

Adicionando validações

class User

  # obrigatoriedade +++++++++++++++++++++++++++++++++++++
  validates_presence_of :nome
  validates_presence_of :nickname

  # validando o formato +++++++++++++++++++++++++++++++++
  # nao use essa REGEX em seus projetos, é mto simples!!!
  REGEX_EMAIL = /[a-zA-Z0-9_.]+@([a-z0-9_]+\.)+[a-z]{2,5}\z/
  validates_format_of :email, :with => REGEX_EMAIL, allow_blank => false
end

Rodando nossa aplicação

Suba o MongoDB

[MONGODB_HOME]/bin/mongod &

Agora sua aplicação

ruby [app_name_dir]/script/server &

Em um browser entre: http://localhost:3000/users e divirta-se! Teste o MongoDB…

Testando

Com o MongoMapper é muito facil escrever testes, mas por favor, não escreva só testes tão obvios e nem faça tanta duplicação do código como neste exemplo!!!
Essa classe como é filha de ActiveSupport::TestCase terá o método tearDown adicionado, que será encarregado de remover os dados do banco no final do teste, já que no MongoDB os testes não serão envolvidos em uma transação do banco.

require 'test_helper'

class UserTest < ActiveSupport::TestCase

  test "validar a presença do nome" do
    user = User.new
    user.save
    assert_equal "can't be empty", user.errors.on(:nome)
  end

  test "validar a presença do email" do
    user = User.new
    user.save
    assert_equal "is invalid", user.errors.on(:email)
  end

  test "ter o e-mail com letrar minusculas" do
    user = User.new
    user.save
    user.email = "ALAN@EMAIL.COM"
    assert_equal "is invalid", user.errors.on(:email)
  end

  test "ter um email valido" do
    user = User.new
    user.save
    user.email = "123alan@email"
    assert_equal "is invalid", user.errors.on(:email)
  end

  test "gravar o usuario quando estiver corretamente preenchido" do
    user = User.new
    user.email = "alan@email.com"
    user.nickname = "alan"
    user.nome = "Alan"
    user.save
    assert_equal true, user.errors.empty?
  end
end

Então é isso, acho que agora você esta mais encorajado a escrever usa primeira aplicação com Rails e MongoDB! Os fontes usados neste post podem ser encontrados no git: http://github.com/alanrrb/Primeiro-projeto-Rails-com-MongoDB

Ah! Não se esqueça de deixar seu comentário!

Link deste post

10 minutos de Ruby e MongoDB

Continuando os meus estudos no movimento NoSQL, minha nova diversão é o MongoDB, mais um banco baseado em documentos. Agora você vai me perguntar: “Mas é o CouchDB que você estava estudando a um tempo atrás?”, calma caro leitor, é sempre bom ter varias ferramentas na caixa!
Vamos a uma breve descrição do MongoDB:

• MongoDB tem coleções de dados, mas não tabelas como conhecemos. Diferente do CouchDB, que também é um banco orientado a documentos, o MongoDB tem namespaces para dados, estes são “schema-less”, assim os dados poderiam estar organizados por namespaces. Você pode ter seus dados em cada coleção, semelhante ao ActiveRecord com Mysql ou qualquer SGDB.

• MongoDB tem indexes. Mesmo que que em cada coleção não tenha um “schema”, podemos ainda assim criar indexes e deixar as consultas ainda mais rápidas.

• MongoDB tem uma linguagem de consulta. Embora você possa usar o JavaScript para pesquisa através de uma coleção, como CouchDB, você também terá acesso a uma rica linguagem de consulta que pode filtrar com base nos campos, como o SQL, e filtrar com base no conteúdo dos documentos incorporados. Em vez de um complexo JOIN, você pode consultar todos os documentos da coleção de Posts que tiveram um comentário ou mais comentários no último mês de forma simples.

Bem vamos ao que interessa, a diversão!!!

Começaremos instalando o MongoDB, para não ser repetitivo, você encontrará mais informações no site oficial.

Galera do MacOS, prefiram seguir as instruções ao invés de usar o macports, eu tive problemas instalando o mongodb por ele(na verdade com as dependências), as instruções no site do MongoDB são muito mais simples.

Bem com tudo instalado vamos ao Ruby. Primeiro instale as gems:

gem install gemcutter

Depois as gems dos drivers do MongoDB.

gem install mongo
gem install mongo_ext

Só mais 8 minutos…

Em um terminal IRB rode.

require 'rubygems'
require 'mongo'

Conectando no banco:

conn = Mongo::Connection.new
db = conn.db("meu_bd")

Definindo uma coleção

coll_usuarios = db.collection("usuarios")

Inserindo documentos em uma coleção

coll_usuarios.insert({:nome => "Alan",
:email => "alanrrb@gmail.com",
:nickname => "alanrrb"})

coll_usuarios.insert({:nome => "Jose",
:email => "jose12332@gmail.com",
:nickname => "jose123321"})

coll_usuarios.insert({:nome => "Tom",
:email => "tom321123@gmail.com",
:nickname => "tom321123"})

Consultando um registro

usuario = coll_usuarios.find_one()
p usuario

{"_id"=>4b7e23b01919ba0353000001, "nome"=>"Alan", "email"=>"alanrrb@gmail.com", "nickname"=>"alanrrb"}

Buscando todos documentos com o nome “Tom”

coll_usuarios.find(:nome => "Tom").each do |doc|
p doc
end

{"_id"=>4b7e23b01919ba0353000003, "nome"=>"Tom", "email"=>"tom321123@gmail.com", "nickname"=>"tom321123"}

Mais 5 minutos…

E lá vem você com mais uma pergunta: “E aí, como incluir MongoDB em meus projetos Ruby e/ou Rails?”
E eu novamente lhe trago uma resposta… Existem alguns projetos interessantes de Object Mapper para MongoDB, destes o qual eu mais me interessei foi este MongoMapper, por parecer mais maduro e estar pronto para coloca-lo em produção sem grandes receios.

Mapeando Documentos

require 'mongo_mapper'

MongoMapper.database = "meu_bd"

class Usuario
include MongoMapper::Document

key :nome, String
key :email, String
key :nickname, String
end

Criando documentos e salvando:

marcia = Usuario.new
marcia.nome = "Marcia"
marcia.email = "email_marcia@gmail.com"
marcia.nickname = "nick_marcia"

marcia.save

Complicando um pouco mais, vamos adicionar relacionamentos

class Usuario
include MongoMapper::Document

many :pagamentos
end

class Pagamento
include MongoMapper::Document

key :valor, Float

belongs_to :usuario
end

marcia.pagamentos << Pagamento.new(:valor => 1.15)
marcia.save

Semelhante a um framework que conhecemos, o MongoMapper gera automaticamente alguns métodos, então é possível fazer isso:

alan = Usuario.find_by_nome("Alan")
p alan

#<Usuario nickname: "alanrrb", nome: "Alan", _id: 4b7e23b01919ba0353000001, email: "alanrrb@gmail.com">

Criando um documento e persistindo.

david = Usuario.create(:nome => "David", :email => "david321123@gmail.com", :nickname => "david")
p david

#<Usuario nickname: "david", nome: "David", _id: 4b7e23b11919ba0353000006, email: "david321123@gmail.com">

Se você conhece o ActiveRecord, com certeza viu algumas semelhanças e já esta com algumas ideias para incluir MongoDB nos seus próximos projetos, mas isso será assunto para a próximo post.

Os códigos usados neste post estão publicados aqui.

Por enquanto é só, não esqueçam de deixar seus comentários!

Link deste post
Tags: Uncategorized