Posts Tagged ‘end’

Ruby usando DRb (Distributed Ruby)

2 Comments
Postado em 18 jun 2009
Categoria(s) Ruby

DRb permite programas em Ruby se comunicar uns com os outros na mesma máquina ou através de uma rede, aplicação cliente/servidor. DRb utiliza o método de invocação remota (RMI) para transmitir comandos e dados entre os processos.

Nesse post vamos criar dois programas, o servidor e o cliente usando DRb.

Construíndo o servidor (server.rb):

1
2
3
4
5
6
7
8
9
10
11

require 'drb'
 
class Server
  def hello
    "Hello, This is a Distributed Ruby (DRb) Example"
  end
end
 
server_object = Server.new
DRb.start_service('druby://localhost:9000', server_object)
DRb.thread.join

Entendendo o código do servidor:

require 'drb'

A linha acima apenas requere a biblioteca DRb, essa biblioteca que a responsável por fazer a comunicação remota. Você pode encontrar mais informações a seu respeito em: http://www.ruby-doc.org/stdlib/libdoc/drb/rdoc/index.html.

class Server
  def hello
    "Hello, This is a Distributed Ruby (DRb) Example"
  end
end

O código acima apena cria uma classe e o método hello, que imprime uma mensagem.

server_object = Server.new
DRb.start_service('druby://localhost:9000', server_object)
DRb.thread.join

Essas três linhas acima que fazem o servidor funcionar, a primeira linha apenas faz a instância da classe Server, a segunda linha inicia o serviço remoto no endereço druby://localhost:9000 disponibilizando o objeto server_object, a terceira linha inicia uma thread no servidor para aceitar requisições remotas.

Construíndo o cliente (client.rb):

1
2
3
4
5
6

require 'drb'
 
DRb.start_service
obj = DRbObject.new(nil, 'druby://localhost:9000')
 
puts obj.hello

Entendendo o código do cliente:

require 'drb'

A linha acima apenas requere a biblioteca DRb, essa biblioteca que a responsável por fazer a comunicação remota. Você pode encontrar mais informações a seu respeito em: http://www.ruby-doc.org/stdlib/libdoc/drb/rdoc/index.html.

DRb.start_service
obj = DRbObject.new(nil, 'druby://localhost:9000')

As suas linhas acima inicia o serviço remoto com o servidor, a primeira inicializa o serviço e a segunda estabelece conexão com o servidor no endereço druby://localhost:9000 obtendo o objeto Server.

puts obj.hello

Essa linha acima invoca o método hello do objeto remoto Server.

Rodando o servidor:

Para inicializar o servidor digite na linha de comando:

ruby server.rb

Não será exibida nenhuma mensagem, o servidor apenas ficará esperando novas requisições remotas.

Rodando o cliente:

ruby client.rb

Quando você rodar o cliente terá como retorno a mensagem:

Hello, This is a Distributed Ruby (DRb) Example

Pronto! Esse recurso é muito interessante. ;-)

Se você gostou desse texto e acha que ajudou você, me recomende: Recommend Me.

  • Share/Bookmark
Tags: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,

Ruby como verificar se uma variável existe similar ao isset do PHP

4 Comments
Postado em 17 jun 2009
Categoria(s) Ruby

No PHP existe a função isset ela é muito interessante para testar se uma variável existe, ela retorna true caso exista e false caso contrário.

Por exemplo:

1
2
3
4
5
6
7
8

public function cleanAttributes($params)
{
  if (isset($params['title'])) {
    $params['title'] = strip_tags($params['title']);
  }
 
  return $params;
}

No Ruby você pode fazer o mesmo usando o operador defined?.

Por exemplo:

1
2
3
4
5
6
7
8
9

def clean_attributes(params)
  if defined?(params['title'])
    if !params['title'].nil?
      params['title'] = params['title'].strip_tags
    end
  end
 
  return params
end

Se você gostou desse texto e acha que ajudou você, me recomende: Recommend Me.

  • Share/Bookmark
Tags: , , , , , , , , , , , , , , , , , , , , , ,

Especificando relacionamento nos modelos em Ruby on Rails

No Comments
Postado em 06 dez 2008
Categoria(s) Ruby, Ruby on Rails, SQL

O Active Record suporta três tipos de relacionamentos entre tabelas: de um para um, um para muitos e de muitos para muitos. Você indica esses relacionamentos ao adicionar declarações aos seus modelos: has_one, has_many, belongs_to e o chamado has_add_belongs_to_many.

Relacionamento de um para um

Uma associação de um para um (ou, mais exatamente, um relacionamento de um para zero e de zero para um) é implementado com uma chave estrangeira em uma linha de uma tabela para referenciar pelo menos uma única linha em outra tabela. Um relacionamento de um para um poderia existir entre pedidos e faturas: para cada pedido há pelo menos uma fatura.

Relacionamento de um para um

Relacionamento de um para um

1
2
3
4

class Invoice < ActiveRecord::Base
  belongs_to :order
 #...
end
1
2
3
4

class Order < ActiveRecord::Base
  has_one :invoice
  #...
end

Como o exemplo mostra, declaramos isso no Rails, adicionando uma declaração has_one ao modelo Order e acrescentando uma declaração belongs_to ao modelo Invoice.

Há uma regra importante ilustrada aqui: o modelo para a tabela que contém a chave estrangeira sempre tem a declaração belongs_to.

Relacionamento de um para muitos

Uma associação de um para muitos permite representar uma coleção de objetos. Por exemplo, um pedido poderia conter um número qualquer de itens de linha associados. No banco de dados, todas as linhas da tabela do item de linha para um pedido particular contêm uma coluna de chave estrangeira que referencia esse pedido.

Relacionamento de um para muitos

Relacionamento de um para muitos

1
2
3
4

class LineItem < ActiveRecord::Base
  belongs_to :order
  #...
end
1
2
3
4

class Order < ActiveRecord::Base
  has_many :line_items
  #...
end

No Active Record, o objeto pai (o que contém logicamente uma coleção de objetos filhos) utiliza has_many para declarar seu relacionamento com a tabela filha, e esta utiliza belongs_to para indicar seu pai. No nosso exemplo, a classe LineItem belongs_to :order e a tabela orders has_many :line_items.

Observe mais uma vez que, como o item de linha contém a chave estrangeira, ele tem a declaração belongs_to.

Relacionamento de muitos para muitos

Por fim, poderíamos categorizar nossos produtos. Um produto pode pertencer a muitas categorias e cada categoria pode conter múltiplos produtos. Esse é um exemplo de um relacionamento de muitos para muitos. É como se cada lado do relacionamento contivesse uma coleção de itens no outro lado.

Relacionamento de muitos para muitos

Relacionamento de muitos para muitos

1
2
3
4

class Category < ActiveRecord::Base
  has_and_belongs_to_many :products
  #...
end
1
2
3
4

class Produt < ActiveRecord::Base
  has_and_belongs_to_many :categories
  #...
end

No Rails expressamos isso adicionando a declaração has_and_belongs_to_many aos dois modelos. De agora em diante, só utilizarei a forma abreviada, habtm, dessa declaração.

Associações de muitos para muitos são simétricas – as duas tabelas unidas declaram a associação entre uma e a outra utilizando habtm.

Dentro do banco de dados, associações de muitos para muitos são implementadas com a utilização de uma tabela de junção intermediária. Essa tabela contém pares de chave estrangeira que vinculam as duas tabelas alvo. O Active Record supõe que o nome dessa tabela de junção seja a concatenação dos dois nomes da tabela alvo em ordem alfabética. No nosso exemplo, associamos a tabela categories à tabela products e o Active Record irá procurar uma tabela de junção chamada categories_products.

Fonte: Thomas, Dave; Hansson, David Heinemeier. Desenvolvimento Web Ágil com Rails.

Se você gostou desse texto e acha que ajudou você, me recomende: Recommend Me.

  • Share/Bookmark
Tags: , , , , , , , , , , , , , , , , , , , , , , , , ,