Arquivo da categoria ‘Ruby on Rails’

Na maioria das vezes é útil utilizar componentes de listas conhecidos como Combobox ou Dropdown para mostrar relacionamentos de dados entre tabelas e de uma forma amigável exibir a descrição dos itens de dados e manipular seu identificador único. Para isto o Rails nos disponibiliza componentes e classes no qual nos permite manipular dados através de objetos e persisti-los em um banco de dados relacional usando o Active Record. Um relacionamento de dados mais simples é criado através de duas tabelas, sendo uma tabela pai que contem os dados mestres e uma filho que contem um ou mais identificadores relacionados ao pai. Um modo de fácil de identificar e tradicional de utilizar relacionamentos em um banco de dados é através de chaves estrangeiras, uma chave estrangeira é um campo, que aponta para a chave primária de outra tabela ou da mesma tabela. Ou seja, passa a existir uma relação entre duas tabelas ou de uma única tabela. A finalidade da chave estrangeira é garantir a integridade dos dados referenciais, pois apenas serão permitidos valores que supostamente vão aparecer na base de dados e estão ligados ao registro mestre.

Com associações do Active Record, podemos agilizar os processos de operações declarativas dizendo ao Rails que há uma conexão entre os dois modelos. Você pode usar belongs_to e has_many para criar um ligação simples entre dois modelos, a associação has_many indica uma ligação de um-para-muitos com outro modelo. Muitas vezes você vai encontrar essa associação no “outro lado” de uma associação belongs_to.

Associations: http://guides.rubyonrails.org/association_basics.html

No conceito de aplicações Rails você não precisa de restrições de chave estrangeira para que o Active Record possa mapear corretamente os relacionamentos. Você pode usar as validações para garantir a integridade dos dados. O Rails Migration não fornece provedor ajudante para criar chaves estrangeiras. Você pode criar seu próprio SQL para a restrição na migração ou usar o do Foreigner Gem. O Foreigner irá fornecer métodos auxiliares para a criação de restrições em uma migração.

Foreigner Gem: https://github.com/matthuhiggins/foreigner

Exibindo Relacionamentos

1 – Após criar um novo projeto Rails, o configure adequadamente para acessar o banco de dados MySQL, crie os modelos disponibilizados com código abaixo:

# Modelo Participante
rails g model participante nome:string sobrenome:string cargo_id:integer data:datetime salario:float genero:string ativo:boolean observacao:string

# Modelo Cargo
rails g model cargo desc_cargo:string
Console - Rails - Modelos

Console – Rails – Modelos

2 – Migre os modelos para criar as tabelas físicas no banco de dados:

Rails Migration

Rails Migration

3 – Abra o Rails Command  e utilize o modelo Cargo para criar novos registros no banco de dados:

# Grava objetos no banco de dados

Cargo.create(desc_cargo: "Vocalista")
Cargo.create(desc_cargo: "Guitarrista")
Cargo.create(desc_cargo: "Baixista")
Cargo.create(desc_cargo: "Baterista")
Rails - Command

Rails – Command

4 – O ajudante de referências não cria restrições de chave estrangeira para você. Você precisar cria-las e executa-las manualmente utilizando scripts SQL ou um plug-in que adiciona suporte a chave estrangeira. Você pode utilizar o código abaixo para criar uma restrição no banco de dados:

-- Cria Chave Estangeira
ALTER TABLE participantes
 ADD FOREIGN KEY (cargo_id)
 REFERENCES cargos(id)
MySQL - Chave Estrangeira

MySQL – Chave Estrangeira

5 – Utilize os códigos abaixo e rode sua aplicação:

Ruby on Rail - Aplicação

Ruby on Rail – Aplicação

6 – Assim que os dados forem enviados o Active Record gravará o conteúdo dos objetos no banco de dados relacional, você pode verificar na pagina que mostramos a descrição do campo cargo toda vez que utilizamos os dados da tabela de Cargos, porem na tabela Participante apenas seu identificador é gravado formando o relacionamento entre as duas tabelas:

MySQL - Workbench

MySQL – Workbench

Exemplo:

Neste exemplo criamos duas tabelas no banco de dados MySQL e as relacionamos através da chave primaria e uma chave estrangeira. Usamos um elemento Rails para tornar este relacionamento amigável, exibindo assim a descrição do relacionamento mas manipulando seu identificador e os persistindo através do Active Record.

Ruby

Model
Participante

class Participante < ActiveRecord::Base

  #Cria relacionamento
  belongs_to :cargo

  # Cria validação
  validates  :nome, :sobrenome, :data, :salario, :genero,
             :presence => true#{:message => "Campo obrigatório"}    

  # Regex - valores alphanumericos
  validates  :nome, :sobrenome,
             :format => {:with => /[A-Za-z]+/,
                         :message => "Permitido somente caracteres letras."}
end

Cargo

class Cargo < ActiveRecord::Base

  # Relacionamento
  has_many :participante

end

View

<h1>Desenvolvimento Aberto</h1>
<h2>Ruby on Rails - Elementos - Form </h2>

<%= form_for @modelo, :url => {:action => :create} do  |cad|%>

<% if @modelo.errors.any?  %>
<h3>Erros: </h3>
<ul style="color:red">
	<% @modelo.errors.full_messages.each do |menssagem| %>
	<li>
		<%= menssagem %>
	</li>
	<% end %>
</ul>
<% end %>
<fieldset>
	<legend>
		Cadastro:
	</legend>
	<table>
		<tr>
			<td> <%= cad.label :nome%> </td>
			<td> <%= cad.text_field :nome  %> </td>
		</tr>
		<tr>
			<td><%= cad.label :sobrenome%></td>

			<td><%= cad.text_field :sobrenome, :size => "35x10"%></td>
		</tr>

		<tr>
			<td><%= cad.label :cargo%></td>
			<td><%= collection_select(:participante, :cargo_id, Cargo.all, :id, :desc_cargo)%> </td>
		</tr>

		<tr>
			<td><%= cad.label :data%></td>

			<td><%= cad.date_field :data, :size => "15x10"%></td>
		</tr>

		<tr>
			<td><%= cad.label :salario%></td>
			<td><%= cad.text_field :salario, :size => "10x10"%></td>
		</tr>

		<tr>
			<td><%= cad.label :genero%></td>
			<td><%= cad.collection_radio_buttons :genero, [["Masculino", "Masculino"] ,["Feminino", "Feminino"]] ,
        :first, :last, { item_wrapper_tag: false } %></td>
		</tr>
		<tr>
			<td><%= cad.label :ativo%></td>
			<td><%= cad.check_box :ativo %></td>
		</tr>

		<tr>
			<td><%= cad.label :observacao%></td>
			<td><%= cad.text_area :observacao , :size => "40x10" %></td>
		</tr>

	</table>
</fieldset>
<p>
	<%= cad.submit "Adicionar dados" %>
</p>

<% end %>

Controller

class MeucontroleController < ApplicationController
  # Controladores
  def index
    @modelo  = Participante.new
  end

  def new
    @modelo  = Participante.new
  end

  # Cria registro
  def create
    @modelo = Participante.new(modelo_params)
    if @modelo.save

      flash[:notice] = "Dados Salvos com sucesso."
      render "index"
    else
    # Você pode colocar uma menssagem aqui.
      render "index"
    end
  end

  # Define parametros requeridos
  private

  def modelo_params
    params.require(:participante).permit(:nome, :sobrenome, :cargo_id, :data,
    :salario, :genero, :ativo, :observacao)
  end

end

Anúncios

Ruby on Rails – Elementos – Form – Linux

Publicado: 5 de fevereiro de 2015 em Ruby on Rails

O Rails torna fácil e simples criar uma interface gráfica de usuário acabando com a complexidade na criação de elementos para seus formulários web, fornecendo ajudantes de visão para gerar a marcação HTML para seus Forms. No entanto, uma vez que esses ajudantes têm diferentes casos de uso, os desenvolvedores precisam conhecer as diferenças entre os métodos de ajuda antes de colocá-los em uso.

O Rails fornece uma série de ajudantes para gerar elementos de formulário, tais como caixas de seleção, campos de texto, botões de rádio e vários outros. Você ainda pode adicionar Widgets externos através de um GEM ou frameworks completos como o Apotomo e vários outros.

Rails Form: http://guides.rubyonrails.org/form_helpers.html

Usando Elementos de Formulários

1 – Crie um projeto Ruby on Rails para o banco de dados MySQL, o configure adequadamente, use os respectivos códigos abaixo para completar os arquivos de modelo, visão e controlador:

Migra modelo – Migrate


rails g model modelo01 nome:string sobrenome:string cargo:string data:datetime salario:float genero:string ativo:boolean observacao:string
rake db:migrate

Rails - Elementos - FORM

Rails – Elementos – FORM

Exemplo:

Neste exemplo criamos um modelo de dados e o utilizamos para gravar dados inseridos pelo usuário em um formulário web.

Ruby on Rails

Model

class Modelo01 < ActiveRecord::Base
  
  # Cria validação
  validates  :nome, :sobrenome, :cargo, :data, :salario, :genero, 
             :presence => true#{:message => "Campo obrigatório"}    
                  

  # Regex - valores alphanumericos
  validates  :nome, :sobrenome, :cargo,
             :format => {:with => /[A-Za-z]+/,
                         :message => "Permitido somente caracteres alphanuméricos"}
end

View

<h1>Desenvolvimento Aberto</h1>
<h2>Ruby on Rails - Elementos - Form </h2>

<%= form_for @modelo, :url => {:action => :create} do  |cad|%>

<% if @modelo.errors.any?  %>
<h3>Erros: </h3>
<ul style="color:red">
	<% @modelo.errors.full_messages.each do |menssagem| %>
	<li>
		<%= menssagem %>
	</li>
	<% end %>
</ul>
<% end %>
<fieldset>
	<legend>
		Cadastro:
	</legend>
	<table>
		<tr>
			<td> <%= cad.label :nome%> </td>
			<td> <%= cad.text_field :nome  %> </td>
		</tr>
		<tr>
			<td><%= cad.label :sobrenome%></td>

			<td><%= cad.text_field :sobrenome, :size => "35x10"%></td>
		</tr>

		<tr>
			<td><%= cad.label :cargo%></td>
			<td><%= cad.select :cargo, options_for_select([["Vocalista", "Vocalista"],
			["Guitarrista", "Guitarrista"] ,
			["Baixista","Baixista"],
			["Baterista","Baterista"] ]),
        html_options= {:style => "width: 100px;"} %></td>
		</tr>

		<tr>
			<td><%= cad.label :data%></td>

			<td><%= cad.date_field :data, :size => "15x10"%></td>
		</tr>

		<tr>
			<td><%= cad.label :salario%></td>
			<td><%= cad.text_field :salario, :size => "10x10"%></td>
		</tr>

		<tr>
			<td><%= cad.label :genero%></td>
			<td><%= cad.collection_radio_buttons :genero, [["Masculino", "Masculino"] ,["Feminino", "Feminino"]] ,
        :first, :last, { item_wrapper_tag: false } %></td>
		</tr>
		<tr>
			<td><%= cad.label :ativo%></td>
			<td><%= cad.check_box :ativo %></td>
		</tr>

		<tr>
			<td><%= cad.label :observacao%></td>
			<td><%= cad.text_area :observacao , :size => "40x10" %></td>
		</tr>

	</table>
</fieldset>
<p>
	<%= cad.submit "Adicionar dados" %>
</p>

<% end %>

Controller

class MeucontroleController < ApplicationController
  # Controladores
  def index
    @modelo  = Modelo01.new
  end

  def new
    @modelo  = Modelo01.new
  end

  # Cria registro
  def create
    @modelo = Modelo01.new(modelo_params)
    if @modelo.save      
      
      flash[:notice] = "Dados Salvos com sucesso."
      render "index"
    else
      # Você pode colocar uma menssagem aqui.
      render "index"
    end
  end

  # Define parametros requeridos
  private

  def modelo_params
    params.require(:modelo01).permit(:nome, :sobrenome, :cargo, :data,
                                     :salario, :genero, :ativo, :observacao)
  end

end

Em ciência da computação teórica e teoria da linguagem formal, uma expressão regular abreviada de Regex ou Regexp e, por vezes chamado de uma expressão racional é uma sequência de caracteres que forma um padrão de pesquisa, principalmente para uso na correspondência de padrões com Strings, ou sequência correspondente, ou seja, como operações de localizar e substituir. O conceito surgiu na década de 1950, quando o matemático americano Stephen Kleene formalizava a descrição de uma linguagem regular, e entrou em uso comum com os utilitários Unix de processamento de texto.

Cada caractere em uma expressão regular ou é entendido como um MetaCharacter com seu significado especial, ou um caractere regular com o seu significado literal. Em conjunto, eles podem ser usados para identificar material textual de um determinado padrão, ou processar um número de instâncias do mesmo que podem variar de uma igualdade exata para uma semelhança muito geral do padrão.

O Regex pode ser usado para analisar rapidamente grandes quantidades de texto para encontrar padrões de caracteres específicos; para extrair, editar, substituir ou excluir substrings de texto, também é comum serem utilizadas para validar campos.

Regular Expression

Existe muito material sobre expressões regulares, inclusive o Ruby contempla classes para combinar sequências de caracteres contra padrões especificados por expressões regulares

Regex: http://www.ruby-doc.org/core-2.2.0/Regexp.html

Por outro lado existem alguns sites que proporcionam ótimos materiais sobre Regex e permitem que você crie e teste sua própria expressão regular antes de a utilizar.

RegExr: http://regexr.com/

Expressão regular que contempla caracteres maiúsculos e minúsculos: Pattern [a-zA-Z]+

Regex - [a-zA-Z]+

Regex – [a-zA-Z]+

Expressão regular que contempla números inteiros e flutuantes: Pattern (?:\d*\.)?\d+

Regex - (?:\d*\.)?\d+

Regex – (?:\d*\.)?\d+

Usando Expressões Regulares

1 – Crie uma aplicação web dinâmica JSF e utilize os códigos abaixo:

JSF - Validando Expressões Regulares

JSF – Validando Expressões Regulares

Exemplo:

Neste exemplo utilizamos expressões regulares para validar o conteúdo dos campos de uma aplicação Rails. Na aplicação se um campo de texto conter caracteres que não correspondem a expressão serão automaticamente invalidados.

Ruby

Model – modelo01.rb

class Modelo01 < ActiveRecord::Base

  # Cria validação
  validates  :nome, :sobrenome, :cargo, :salario,
             :presence => {:message => "Campo obrigatório"}             

  # Regex - valores alphanumericos
  validates  :nome, :sobrenome, :cargo,
             :format => {:with => /[A-Za-z]+/,
                         :message => "Permitido somente caracteres alphanuméricos"}

end

View – index.html.erb

<h1>Desenvolvimento Aberto</h1>
<h2>Ruby on Rails - Validate </h2>

<%= form_for @modelo, :url => {:action => :create} do  |cad|%>

<% if @modelo.errors.any?  %>
<h3>Erros: </h3>
<ul style="color:red">
	<% @modelo.errors.full_messages.each do |menssagem| %>
	<li>
		<%= menssagem %>
	</li>
	<% end %>
</ul>
<% end %>

<p>
	<%= cad.label :nome%>
	<br />
	<%= cad.text_field :nome  %>
</p>

<p>
	<%= cad.label :sobrenome%>
	<br />
	<%= cad.text_field :sobrenome, :size => "35x10"%>
</p>

<p>
	<%= cad.label :cargo%>
	<br />
	<%= cad.text_field :cargo, :size => "30x10"%>
</p>

<p>
	<%= cad.label :salario%>
	<br />
	<%= cad.text_field :salario, :size => "15x10"%>
</p>

<p>
	<%= cad.submit "Adicionar dados" %>
</p>

<% end %>

Controller – meucontrole_controller.rb

class MeucontroleController < ApplicationController

  # Controladores
  def index
    @modelo  = Modelo01.new
  end

  def new
    @modelo  = Modelo01.new
  end

  # Cria registro
  def create
    @modelo = Modelo01.new(modelo_params)
    if @modelo.save

      # Você pode colocar uma menssagem aqui.
      render "index"
    else
      render "index"
    end
  end

  # Define parametros requeridos
  private

  def modelo_params
    params.require(:modelo01).permit(:nome, :sobrenome, :cargo, :salario)
  end

end

O Rails possibilita trabalhar com Javascript de um modo automático e moderno, um  destes modos é o Asset Pipeline (pipeline ativo) que fornece uma estrutura para concatenar e minimizar ou comprimir JavaScript e CSS ativos. Ele também adiciona a capacidade de escrever esses ativos em outros idiomas e pré processadores como CoffeeScript, Sass e ERB. O pipeline ativo é ativado por padrão mas você pode desabilita-lo quando necessário. A outra forma de usar Javascript é utilizando Unobtrusive Javascript, o Rails usa uma técnica chamada “Unobtrusive JavaScript” para lidar/anexar com o JavaScript no DOM. Esta função é geralmente considerada uma das melhores práticas dentro da comunidade de desenvolvimento Frontend.

Asset Pipeline: http://guides.rubyonrails.org/asset_pipeline.html

Unobtrusive JavaScript: http://guides.rubyonrails.org/working_with_javascript_in_rails.html

Usando uma Biblioteca Externa

1 – Crie um projeto Rails para o banco de dados MySQL, e configure adequadamente, criando um modelo, uma visão e um controle de acordo com o código abaixo. Para utilizar o Javascript vamos usar o Asset Pipeline que já é habilitado por padrão no Rails. Abra a pasta App do seu projeto e em seguida a pasta Assets/Javascript, crie um pasta dentro dela chamada DAscripts:

Asset Pipeline - Dascripts

Asset Pipeline – Dascripts

2 – Crie um arquivo chamado meujsteste.js e utilize o respectivo código logo abaixo:

Javascript - MeujsTeste.js

Javascript – MeujsTeste.js

3 – Use os códigos abaixo, rode sua aplicação e no navegado exiba o código fonte. Você pode ver que o Rails criou automaticamente as tags de script HTML apontando para seu Asset para utilizarmos as funções javascript que definimos na visão:

Rails - Exibir Código do Navegador

Rails – Exibir Código do Navegador

4 – Você pode utilizar o mouse no campo de entrada para que o evento seja disparado e o javascript exiba um log da ação que o usuário está efetuando:

Ruby on Rails - App

Ruby on Rails – App

Exemplo:

Neste exemplo utilizamos Javascript através do Asset Pipeline para imprimir na página os eventos de entrada e saída do mouse em um componente Text_Field do Rails.

Modelo – modelo01.rb

class Modelo01 < ActiveRecord::Base
  
  # Cria validação
  validates  :nome, :sobrenome, :cargo, :salario, :presence => true
  
end

Visão – index.html.erb

<h1>Desenvolvimento Aberto</h1>
<h2>Ruby on Rails - Validate </h2>

<%= form_for @modelo, :url => {:action => :create} do  |cad|%>

<% if @modelo.errors.any?  %>
<h3>Erros: </h3>
<ul style="color:red">
	<% @modelo.errors.full_messages.each do |menssagem| %>
	<li>
		<%= menssagem %>
	</li>
	<% end %>
</ul>
<% end %>

<p>
	<%= cad.label :nome%>
	<br />
	<%= cad.text_field :nome , :onmouseover=>"meuMouseOver()", :onmouseout=>"meuMouseOut()" %>
</p>

<p>
	<%= cad.label :sobrenome%>
	<br />
	<%= cad.text_field :sobrenome, :size => "35x10"%>
</p>

<p>
	<%= cad.label :cargo%>
	<br />
	<%= cad.text_field :cargo, :size => "30x10"%>
</p>

<p>
	<%= cad.label :salario%>
	<br />
	<%= cad.text_field :salario, :size => "15x10"%>
</p>

<p>
	<%= cad.submit "Adicionar dados" %>
</p>

<% end %>

<!-- Div - logs do evento javascript -->
<div id="meulog"></div>

Controlador – meucontrole_controller.erb

class MeucontroleController < ApplicationController

  # Controladores
  def index
    @modelo  = Modelo01.new
  end

  def new
    @modelo  = Modelo01.new
  end

  # Cria registro
  def create
    @modelo = Modelo01.new(modelo_params)
    if @modelo.save

      # Você pode colocar uma menssagem aqui.
      render "index"
    else
      render "index"
    end
  end

  # Define parametros requeridos
  private

  def modelo_params
    params.require(:modelo01).permit(:nome, :sobrenome, :cargo, :salario)
  end

end

Javascript – meujsteste.js

// Desenvolvimento Aberto
// Javascript teste
 
function meuMouseOver() {
    var div = document.getElementById('meulog');
 
    div.innerHTML = div.innerHTML + 'Você entrou no campo nome ';
}
 
function meuMouseOut() {
    var div = document.getElementById('meulog');
 
    div.innerHTML = div.innerHTML + 'Você saiu do campo nome ';
}

Ruby on Rails – Validations – Linux

Publicado: 15 de janeiro de 2015 em Ruby on Rails

O Active Record possui algumas funcionalidades que visam facilitar a validação de campos e economizar tempo do desenvolvedor na criação da interface com o usuário. O Rails utiliza validações de nível de modelo, está é a melhor maneira de garantir que apenas dados válidos serão salvos em seu banco de dados, pois dados essenciais não podem ser ignorados pelos usuários finais. Rails torna as validações fáceis de usar, fornecendo uma base para ajudar nas necessidades comuns, e também permite que você crie seus próprios métodos de validação.

Validate: http://guides.rubyonrails.org/active_record_validations.html

Validando Campos Obrigatórios

Neste walkthrough utilizamos somente os campos de presença, mas você pode executar outros tipos de validações, você pode ver algumas delas clicando aqui.

1 – Crie um projeto do tipo Rails para o banco de dados MySQL e configure seu projeto corretamente para que seja exibida uma visão da pagina índice de sua aplicação. Tenha certeza que você configurou tudo, use as instruções abaixo para criar o controlador e o modelo:

rails g controller meucontrole index

rails g model modelo01 nome:string sobrenome:string cargo:string salario:float

rake db:migrate

rails server
Rails - Console

Rails – Console

2 – Se estiver utilizando a IDE Aptana Studio, você criará por padrão um projeto para o banco de dados SQLite3, você precisa mudar manualmente o arquivo de conexão (figura acima) e adicionar o GEM chamado mysql2, use a figura abaixo para referencia:

Rails - Aptana - Gem - Mysql2

Rails – Aptana – Gem – Mysql2

3 – Após configurar o arquivo de rotas, utilize os códigos abaixo para preencher seu respectivos arquivos do modelo, visão e controlador. Rode sua aplicação e a chame no navegador e você pode ver que os campos são de preenchimento obrigatórios:

Rails - Model - Validation

Rails – Model – Validation

4 – Uma vez que todos os campos satisfazerem a condição de presença do modelo, o registro será inserido com sucesso no banco de dados:

Rails - Active Record - Save

Rails – Active Record – Save

Exemplo:

Neste exemplo criamos um projeto Rails e utilizamos o controlador para exibir um formulário de campos obrigatórios.

Ruby on Rails

Modelo – modelo01.rb

class Modelo01 < ActiveRecord::Base
  
  # Cria validação
  validates  :nome, :sobrenome, :cargo, :salario, :presence => true
  
end

View – index.html.erb

<h1>Desenvolvimento Aberto</h1>
<h2>Ruby on Rails - Validate </h2>
 
<%= form_for @modelo, :url => {:action => :create} do  |cad|%>
 
 <% if @modelo.errors.any?  %>
       <h3>Erros:  </h3>
       <ul style="color:red">
          <% @modelo.errors.full_messages.each do |menssagem| %>
          <li> <%= menssagem %> </li>
          <% end %>
       </ul>
    <% end %>

    <p>
        <%= cad.label :nome%> <br />
        <%= cad.text_field :nome%>
    </p>

    <p>
        <%= cad.label :sobrenome%> <br />
        <%= cad.text_field :sobrenome, :size => "35x10"%>
    </p>
 
    <p>
        <%= cad.label :cargo%> <br />
        <%= cad.text_field :cargo, :size => "30x10"%>
    </p>
 
    <p>
        <%= cad.label :salario%> <br />
        <%= cad.text_field :salario, :size => "15x10"%>
    </p>
 
   
    <p> <%= cad.submit "Adicionar dados" %></p>
 
<% end %>

Controller- meucontrole_controller.rb

class MeucontroleController < ApplicationController

  # Controladores
  def index
    @modelo  = Modelo01.new
  end

  def new
    @modelo  = Modelo01.new
  end

  # Cria registro
  def create
    @modelo = Modelo01.new(modelo_params)
    if @modelo.save

      # Você pode colocar uma menssagem aqui.
      render "index"
    else
      render "index"
    end
  end

  # Define parametros requeridos
  private

  def modelo_params
    params.require(:modelo01).permit(:nome, :sobrenome, :cargo, :salario)
  end

end

Routes- routes.rb

Rails.application.routes.draw do
  
  get 'meucontrole/index'

  # Define rota do controle
  resources :meucontrole  
 
end


Depois de criar os seus modelos de dados, o Rails lhe fornece automaticamente uma API de banco de dados com abstração que permite criar, recuperar, atualizar e excluir objetos. Você pode utilizar uma gama de instruções Ruby para manipular dados através de objetos fornecidos pelo ORM do Active Record que também lhe proporciona praticidade e segurança pois sua arquitetura foi construída sob as boas praticas de acesso a dados, onde o desenvolvedor não precisa saber de detalhes técnicos sobre os diferentes bancos de dados pois os objetos já incluem recursos para minimizar o acesso ao banco de dados, criação de IDs automáticos e muitas outras vantagens.

Active Record: http://guides.rubyonrails.org/active_record_basics.html

Usando o Active Record no Rails Shell

1 – Em um diretório de sua escolha crie um projeto Ruby on Rails:

RoR - Criar Projeto

RoR – Criar Projeto

2 – Na pasta config da sua aplicação configure os parâmetros de acesso ao MySQL:

RoR - Conexão MySQL

RoR – Conexão MySQL

3 – Entre na pasta do seu projeto, e no terminal crie o modelo e migre o modelo para o banco de dados:

rails g model meumodelo nome:string album:string musica:string
Criar Modelo

Criar Modelo

4 – Entre no Shell utilizando o comando rails para gravar registros no banco de dados através do Active Records, você pode perceber que os comandos SQL utilizados para as operações no banco de dados são mostradas pelo Active Record.

Vamos tomar como exemplo que a Camila goste da banda chamada Stone Temple Pilots, o modelo proporciona que o usuário escolha sua musica e seu álbum preferido:

Active Record - Criar (Inserir)

Active Record – Criar (Inserir)

5 – Também podemos recuperar os dados e altera-los caso a Camila tenha lembrado uma musica que goste mais e deseje alterar seu registro:

Active Record - Alterar Dados

Active Record – Alterar Dados

6 – Se a Camila desejar excluir seu registro:

Active Record - Deleta - Dados

Active Record – Deleta – Dados

7 – Caso queira confirmar o trabalho do Active Record, no meio dos processo acima você pode consultar o banco de dados para ver o resultado de suas operações:

MySQL - Workbench

MySQL – Workbench

Exemplo:

Neste exemplo criamos um projeto e uma aplicação Ruby on Rails e criamos um modelo de dados através de seu ORM e  utilizamos o Active Record para efetuar operações CRUD através do Rails Shell.

Database.yml

Ruby

# MySQL.  Versions 5.0+ are recommended.
#
# Install the MYSQL driver
#   gem install mysql2
#
# Ensure the MySQL gem is defined in your Gemfile
#   gem 'mysql2'
#
# And be sure to use new-style password hashing:
#   http://dev.mysql.com/doc/refman/5.0/en/old-client.html
#
default: &default
  adapter: mysql2
  encoding: utf8
  pool: 5
  username: root
  password: minhasenha
  socket: /var/run/mysqld/mysqld.sock

development:
  <<: *default
  database: DAsandbox

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
  <<: *default
  database: meusite_test

# As with config/secrets.yml, you never want to store sensitive information,
# like your database password, in your source code. If your source code is
# ever seen by anyone, they now have access to your database.
#
# Instead, provide the password as a unix environment variable when you boot
# the app. Read http://guides.rubyonrails.org/configuring.html#configuring-a-database
# for a full rundown on how to provide these environment variables in a
# production deployment.
#
# On Heroku and other platform providers, you may have a full connection URL
# available as an environment variable. For example:
#
#   DATABASE_URL="mysql2://myuser:mypass@localhost/somedatabase"
#
# You can use this database configuration with:
#
#   production:
#     url: <%= ENV['DATABASE_URL'] %>
#
production:
  <<: *default
  database: meusite_production
  username: meusite
  password: <%= ENV['MEUSITE_DATABASE_PASSWORD'] %>

Rails é um framework de desenvolvimento de aplicações web escrito na linguagem Ruby. Ele é projetado para tornar a programação de aplicações web mais fácil, fazendo suposições sobre o que cada desenvolvedor precisa para começar. Ele permite que você escreva menos código enquanto faz mais do que muitas outras linguagens e frameworks.

O Rails utiliza o Object-Relational Mapping, comumente referido como seu ORM, é uma técnica que liga os objetos de uma aplicação para tabelas em um sistema de gerenciamento de banco de dados relacional. Rails utiliza o ORM através do Active Record que pode ser considerado o Model no Pattern MVC – o modelo – é a camada do sistema responsável por representar dados de negócios e sua lógica. O Active Record facilita a criação e utilização de objetos de negócios cujos dados requer armazenamento persistente em um banco de dados. É uma implementação do padrão Active Record, que em si é uma descrição de um objeto do sistema Relational Mapping.

Caso você ainda não tenha instalado o Ruby on Rails em seu computador clique aqui ou talvez queira ver uma introdução mais simples e menos detalhada, usando o Rails a partir de uma IDE, clique aqui.

Rails: http://guides.rubyonrails.org/

Basicamente vamos focar em duas pastas do projeto Rails elas são App e Config,  mais tarde entraremos em mais detalhes sobre a estrutura de diretórios do Rails:

  • App –  Contém os controladores, modelos, visões, ajuda, malas diretas e outros itens para a sua aplicação.
  • Config – Configura rotas de sua aplicação, banco de dados e muito mais.

Criando uma Aplicação Ruby on Rails com MySQL

1 – Após instalar o Ruby, o Rails e suas dependências, abra o terminal do Linux para criar um projeto Rails para MySQL:

rails new MinhaApp -d mysql
Rails - Cria Projeto - MinhaApp

Rails – Cria Projeto – MinhaApp

2 – Após criar o projeto entre na pasta MinhaApp. Dê um pouco de atenção a sua estrutura de arquivos, principalmente as pastas contollers, models e views. Estas pastas são responsáveis pela estrutura básica do Pattern MVC dentro de uma aplicação Rails:

Rails - App - MVC

Rails – App – MVC

3 – Vamos criar um controle chamado meucontrole, este será responsável pelo controlador de nossa aplicação, no terminal digite:

rails g controller meucontrole index
Rails - Cria Controle

Rails – Cria Controle

4 – Na pasta config abra o arquivo database.yml e configure os parâmetros de conexão com o banco de dados MySQL:

Rails - Conexão - MySQL

Rails – Conexão – MySQL

5 – Precisamos criar um modelo para nossa aplicação, no terminal digite:

rails g model meumodelo nome:string sobrenome:string cargo:string salario:float

rake db:migrate
Rails - Cria Modelo

Rails – Cria Modelo

6 – Depois de criar um objeto do modelo podemos utilizar o Active Record através do terminal para inserir uma linha de dados no banco, para isto vamos utilizar o console de comandos do Rails, digite:

rails c

Meumodelo.create(:nome=>'james', :sobrenome=>'Hetfield', :cargo=>'Vocalista/Guitarrista', :salario=>1234.56)
Rails - Console - Active Record

Rails – Console – Active Record

7 – Para visualizar os dados que acabamos de gravar e entender a estrutura dos modelos do Rails no banco de dados, abra o MySQL Workbench e execute uma pesquisa na tabela do seu modelo para ver os dados inseridos através do ORM:

MySQL - Workbench - Modelo

MySQL – Workbench – Modelo

8 – Com o controle e modelo prontos, vamos iniciar o servidor Rails, no terminal digite:

rails server
Rails - Server - Iniciar

Rails – Server – Iniciar

9 – Para testar o servidor, abra seu navegador, digite localhost e a porta de numero 3000:

Rails Server - Localhost

Rails Server – Localhost

10 – Na pasta App/Controllers, abra seu controle e crie uma variável de instancia para seu modelo:

Rails - Controle

Rails – Controle

11 – Na pasta App/Views modifique a View padrão index.html.erb para exibir a pagina html, utilize o código abaixo:

Rails - View

Rails – View

12 – Já temos o Modelo, a Visão e o Controlador, precisamos criar uma rota para que o controlador saiba qual será nossa pagina índice. Na pasta Config, abra o arquivo routes.rb e altere seu conteúdo inserindo uma linha de recursos para seu controle, use a figura abaixo como referencia:

Rails - Configura Rotas

Rails – Configura Rotas

13 – Para rodar sua aplicação abra o navegador e digite o nome do seu controle sobre a porta 3000  do servidor local:

Ruby on Rails - MinhaApp

Ruby on Rails – MinhaApp

Exemplo:

Neste exemplo criamos uma aplicação RoR, usando os conceitos básicos do padrão MVC do Rail, utilizando a pasta App do projeto para os arquivos de modelo, visão e controles e configurando os arquivos responsáveis pela conexão e rotas na pasta Config do projeto.

Ruby on Rails

Controlador – meucontrole_controller.rb

class MeucontroleController < ApplicationController
  def index
     @Modelo = Meumodelo.all
  end
end

Visão – index.html.erb

<h1>Desenvolvimento Aberto</h1>
<h2>Ruby on Rails - Model View Controller</h2>
<h3>Dados - Mysql</h3>
<% @Modelo.each do |dados| %>
<br>
<%=String(dados.id) +  " " + dados.nome +  " " + dados.sobrenome + " " + dados.cargo + " " + String(dados.salario)%>

<%end%>

O MySQL Community Edition é uma versão gratuita do banco de dados de código aberto mais popular do mundo, que é apoiado por uma comunidade ativa de desenvolvedores de código aberto e entusiastas. O MySQL hoje suporta Unicode, Full Text Indexes, replicação, Hot Backup, GIS, OLAP e muitos outros recursos de banco de dados.

O MySQL Workbench fornece aos DBAs e desenvolvedores um ambiente integrado de ferramentas para, design e modelagem do banco de dados, desenvolvimento SQL, administração do banco de dados e migração. O MySQL Workbench necessita de bibliotecas adicionais para que funcione corretamente, deste modo consulte o site oficial caso queira instalar em um sistema operacional diferente do Linux.

MySQL Community Edition: http://www.mysql.com/

O MySQL/Ruby é construído em cima da API C do MySQL, e oferece as mesmas funções para programas Ruby que a API C do MySQL fornece para programas em C.

MySQL/Ruby: http://dev.mysql.com/downloads/ruby.html

Instalando e Testando o MySQL e o MySQL/Ruby API

1-  Para instalar o banco de dados MySQL, a ferramenta de administração digite os comandos abaixo no terminal do Linux. Quando questionado escolha uma senha para o usuário root:

sudo apt-get install mysql-server

sudo apt-get install mysql-workbench

sudo apt-get install libmysqlclient-dev
MySQL Community Edition

MySQL Community Edition

2 – Após a instalação das três aplicações digite no terminal mysql-workbench para abrir a ferramenta de administração e desenvolvimento do MySQL:

MySQL Workbench

MySQL Workbench

3 – Clique no quadro Local Instance e digite a senha para o usuário root para se conectar, rode as instruções SQL abaixo para criar um banco de dados e uma tabela para testes:

Workbench - SQL

Workbench – SQL

4 – De volta ao terminal do Linux, instale as bibliotecas Ruby Dev e o conector Ruby utilizando o seguinte comando:

sudo apt-get install ruby-dev

sudo gem install mysql
Ruby - MySQL - C - API

Ruby – MySQL – C – API

5 – Abra a IDE ou o editor e de sua preferencia e utilize o código abaixo para testar o conector:

Apatna - Programa - MySQL

Apatna – Programa – MySQL

Exemplo:

Neste exemplo instalamos o banco de dados MySQL, sua ferramenta de desenvolvimento e administração e as bibliotecas necessária para que o Workbench funcione corretamente, ainda instalamos e testamos o MySQL Ruby API.

SQL

-- Cria banco de dados
Create database DAsandbox;
 
-- Cria privilegios para o usuário root
Grant all privileges on DAsandbox.*
to 'root'@'localhost' identified by 'password';
 
-- nivela privilegios
FLUSH PRIVILEGES;

-- Usa database
use DAsandbox;

-- Cria tabela
Create table Teste ( 
  id int, 
  nome varchar(50),
  sobrenome varchar(70),
  cargo varchar(30),
  salario decimal(9,2));

-- Insere dados na tabela
insert into Teste values (1, 'John','Lennon',
      'Guitarrista/Vocalista', 1234.56);

-- Testa tabela
select * from Teste;

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# conectar.rb

# Declara driver MySQL
require "mysql"

# Define conexão - Host - usuário - senha
conn = Mysql.new 'localhost', 'root', 'pass'

# Define banco de dados
db = conn.select_db('DAsandbox')

# Define um pesquisa
sql = conn.query('Select * from Teste')

# recupera campos
campos = sql.fetch_fields
row = ""

campos.each do |campo|  
     row = row + String(campo.name).ljust(15)  
end

# Recupeda dados
puts row
puts "-" * 100
puts  sql.fetch_row.join("".ljust(15))

Ruby – Date and Time – Linux

Publicado: 30 de dezembro de 2014 em Ruby on Rails

A classe Time é uma abstração de datas e horários. O tempo é armazenado internamente como o número de segundos com fração desde a época de 01 de janeiro de 1970 00:00 UTC. A classe Time trata os padrões GMT (Greenwich Mean Time) e UTC (Tempo Universal Coordenado) como equivalente. GMT é a maneira mais antiga de se referir a estes tempos de base.

Time: http://ruby-doc.org/core-2.2.0/Time.html

Ruby - Time

Ruby – Time

Exemplo:

Neste exemplo imprimimos datas e horários através da classe Time.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# time.rb

# Utiliza classe de tempo
tempo = Time.new

# Imprime data e hora
puts "Dia: " + String(tempo.day) + "/" + 
               String(tempo.month) + "/" + 
               String(tempo.year)
               
puts "hora: " + String(tempo.hour) + ":" +
                String(tempo.min) + ":" +
                String(tempo.sec)
               
# Imprime data com formato               
puts "Data Formatada: " + tempo.strftime("%d-%m-%Y %H:%M:%S")

Um erro de aplicativo é um erro de tempo de execução que não pode necessariamente ser evitado escrevendo um código livre de erros. Erros de tempo de execução podem ocorrer por uma variedade de razões. No entanto, nem todos os erros devem ser tratados como exceções em seu código. Em alguns casos, um erro de programa pode refletir uma condição de erro esperada ou de rotina. Neste caso, você pode querer evitar o uso de tratamento de exceção para lidar com o erro do programa. Em outros casos, um erro de programa reflete uma condição de erro inesperado que pode ser manipulado em seu código. Por exemplo, mesmo que você tenha verificado para garantir que existe um arquivo, ele pode ser excluído antes que você possa abri-lo, ou ele pode estar corrompido.

A falha do sistema é um erro de tempo de execução que não pode ser tratado por meio de programação de uma maneira significativa. Por exemplo, qualquer método pode lançar uma exceção OutOfMemory se o Runtime for incapaz de alocar memória adicional

O Ruby utiliza blocos para manipular exceções, todo o código contido no bloco pode ser manipulado com a instrução Rescue que previne a interrupção do programa e trata o erro, Ensure que assegura o termino da execução do bloco, Retry que executa novamente o inicio do bloco e o próprio Raise que força uma exceção. A classe Exception o ajuda a manipular os erros como por exemplo, exibindo suas mensagens.

Exception: http://www.ruby-doc.org/core-2.2.0/Exception.html

Ruby - Exception

Ruby – Exception

Exemplo:

Neste exemplo utilizamos os conceitos básicos de tratamento de exceção para manipular erros.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Erros.rb

# Para validar instruções crie um bloco
puts "Erro numero 1: \n\n"
begin

  # Define valores
  numero1 = 10
  numero2 = 0

  # Tenta dividir por zero
  resultado = numero1 / numero2

# Previne o erro e imprime mensagem de erro
rescue Exception => ex
  puts "Houve um erro: " + ex.message

#Garante final da execução do bloco
ensure
  puts "coloque algo aqui caso queira ter certeza da execução." 

end

# Gera seu próprio erro
puts "\nErro numero 2: \n\n"
begin

  # Define valores
  valor1 = 5
  valor2 = 6

  # Raise gera um erro especifico
  if (valor2 > valor1)
    raise "Valor 2 não pode ser maior que o valor 1"
  end

# Rescue impede a interrupção do programa e exibe mensagem
rescue Exception => ex
  puts "Houve um erro: " + ex.message

end