markdown Módulo1 - Conceitosbásicos做Ruby on Rails

Posted 2021-05-06

## Helpers ##

São os `ajudantes` do Ruby. O Ruby nos oferece alguns helpers, para facilitar a escrita do código e gerar alguns elementos de uso do dia a dia, mais facilmente, ex:

```Ruby
<%= link_to "Home", "home#index" %>
```

O código a cima irá gerar um <a></a> para o usuário.

## Módulos ##

Módulos são parecidos com classes, porém não é possível criar objetos a partir deles.

No Ruby uma classe não pode herdar de mais de uma classe e isso pode nos limitar, porém podemos compartilhar (incluir) funcionalidades de módulos dentro de classes e outros módulos.

Os módulos também podem ser usados como namespaces (muito usado no core do Rails).

```Ruby
module MyModule
  #code
end
```

Referência:

https://www.udemy.com/rubyonrails/learn/v4/t/lecture/5178218?start=0

## Herança ##

Herança é um conceito que segue a linha de orientação a objetos de tornar a programação mais próxima da nossa realidade, assim como um filho herda a genética dos pais, quando uma classe herda de outra, essa classe herda seus `atributos` e `métodos`.

A herança tem por maiores benefícios a otimização da produção da aplicação em tempo e em linhas de código graças a reusabilidade de código que a mesma gera.

```Ruby
class Car < Vehicle # O sinal de < é o que indica ao Ruby que a classe Car herda da classe Vehicle.
  #code
end
```

## Classes ##

No ruby existe uma forma simples e eficaz de setar os `gets` e `sets` de uma classe, basta fazendo o seguinte:

```Ruby
class Pessoa
  attr_accessor :nome
  attr_accessor :endereco
  
  def initialize
    @nome
    @endereco
  end
end
```

Dessa maneira, o Ruby irá automaticamente gerar os `gets` e `sets` baseados nos `attr_accessor` que declaramos.

## Strings ##

Para se fazer uma interpolação no ruby basta utilizar `#{}`, exemplo abaixo:

```Ruby
name = "Rails"
puts "Ruby on #{name}"
```

Para concatenar strings, podemos utilizar `+` ou `<<`, exemplo abaixo:

```Ruby
puts "Ruby" + "on" + "Rails"
puts "Ruby" << "on" << "Rails"
```

Para substituir uma string, utilizamos o `gsub`, exemplo abaixo:

```Ruby
"Curso on Rails".gsub("Curso", "Ruby")

Dessa forma, ele irá substituir a string porém não irá salvar essa alteração em uma próxima chamada, para forçar que a string passe a conter o novo valor em definitivo, deverá ser adicionado o símbolo `!` ao final, exemplo:

"Curso on Rasil".gsub!("Curso", "Ruby")
```

## Hashes e Símbolos ##

### Hashes ###

Hashes são listas ordenadas chaveadas, diferente dos arrays, para cada valor contido dentro de um hash, possuímos uma chave para acessá-lo.

### Símbolos ###

Símbolos são parecidos com variáveis, porém são precedidos de `:` como em `:name`, `:age` e possuem uma particularidade interessante na linguagem, vamos entendê-lo exemplificando.

```Ruby
# Hash chaveado com strings
hash = { "nome" => "Luan", "age" => 26 }
hash["nome"]
hash["age"]

# O que são símbolos

color1 = "red"
color2 = "red"

Dessa maneira, temos duas variáveis com o mesmo valor, porém, cada uma ocupa um espaço na memória.

color1 = :red
color2 = :red

Utilizando os símbolos como no exemplo acima, continuamos com duas variáveis, porém, ambas consomem o mesmo valor, e portanto, ocupam somente um espaço na memória, melhor assim o desempenho do nosso hashe.

# Hash chaveado com símbolos

hash = { nome: "Luan", age: 26 }

hash[:nome]
hash[:age] 
```

## Um pouco sobre Ruby, IRB e Pry. ##

### Executando um arquivo Ruby ###

```Ruby
ruby meuarquivo.rb
```

## Conhecendo o Interactive Ruby Shell - IRB ##

Digitando "irb" no terminal, iremos acessar o Shell/Terminal próprio do Ruby, onde poderemos 
executar comandos para o Ruby interpretar.

## Conhecendo o Pry ##

```Text
http://pryrepl.org/
```

O Pry é muito parecido com o IRB, a diferença é que ele possui algumas features a mais, tais como:

- syntax highlighting
- a flexible plugin architecture 
- runtime invocation
- source and documentation browsing

Para utilizá-lo é necessário que seja feita a instalação da gem:

```Text
gem install pry
```

# Bundler (Gerenciador de dependências) #

Abaixo veremos um pouco sobre o bundler, um gerenciador de dependências utilizado no ruby.

## O arquivo Gemfile ##

O arquivo 'Gemfile' é o responsável por fazer o trabalho de gestão das dependências, o Blunder 
utiliza esse cara.

## Criando novos projetos ##

### Para criar um projeto, execute o comando: ###

```Ruby
rails new meuapp
```

### Para criar um projeto com uma versão específica do rails, execute: ###

```Ruby
rails _4.0.0_ new meuapp
```

### Para criar um projeto especificando uma pasta já existente, execute: ###

```Ruby
rails new pasta/subpasta/meuapp
```

### Para criar um projeto especificando o banco de dados, execute: ###

```Ruby
rails new meuapp -d postgresql
```

# Comandos básicos e Gems #

Veremos abaixo alguns comandos básicos e um pouco sobre manipulação de gems.

## Comandos básicos ##

### Verificar a versão instalada do ruby: ###

```Text
ruby -v
```

### Veriicar a versão instalada do rails: ###

```Text
rails -v
```

### Verificar a versão instalada das gem "gerenciador de pacote no ruby" ###

```Text
gem -v
```

### Listar todas as gems instaladas: ###

```Text
gem list
```

### Listar todas as gems instaladas "Com filtragem" ###

```Text
gem list nomedagem
```

## Como instalar uma 'gem' ##

```Text
gem install nomedagem
```

### Instalando uma gem com uma versão específica ###

```Text
gem install nomedagem -v 1.0.0
```

## Como remover uma 'gem' ##

```Text
gem uninstall nomedagem
```

### Como remover uma versão específica de uma 'gem' ###

```Text
gem uninstall nomedagem --version 1.0.0.0
```

### Como remover versões antigas de uma 'gem' ###

```Text
gem cleanup
```

### Como remover versões antigas de uma 'gem' específica ###

```Text
gem cleanup nomedagem
```

### Verificar quais versões antigas de 'gems' podem ser removidas ###

```Text
gem cleanup -d
```