Desenvolvimento Código Aberto

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

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

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")

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)

5 – Utilize os códigos abaixo e rode sua 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:

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

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

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]+

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

Usando Expressões Regulares

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

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 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

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:

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:

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:

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:

2 – Na pasta config da sua aplicação configure os parâmetros de acesso ao 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

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:

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:

6 – Se a Camila desejar excluir seu registro:

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:

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

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:

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

4 – Na pasta config abra o arquivo database.yml e configure os parâmetros de conexão com o banco de dados 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

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)

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:

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

rails server

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

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

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

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:

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

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%>

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

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

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