kernelJ.txt

*https://guides.github.com/
*https://www.atlassian.com/br/git/tutorials

*http://guides.rubyonrails
*http://ruby-toolbox.com/
*https://github.com/avdi
*https://www.programmer-books.com/wp-content/uploads/2018/07/Agile_Web_Development_with_Rails_5.pdf
*https://www.caelum.com.br/download/caelum-ruby-on-rails-rr71.pdf

*https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-20-04-pt
*https://docs.docker.com/engine/install/ubuntu/
*https://docs.docker.com/get-started/

*https://angular.io/guide/setup-local

*https://asdf-vm.com/#/core-manage-asdf-vm

*https://docs.mongodb.com/manual/reference/operator/

*https://github.com/thoughtbot/shoulda-matchers



----------------------- >Angular ------------------------------------

npm install -g @angular/cli                                                  => Install Angular CLI
sudo npm install -g @angular/cli --allow-root
ng new my-app                                                                => criando um app cli
ng serve --open                                                              => Ligar o servidor
https://localhost:4200/.  
ng generate component <nome>                                                 => Gerando componente
ng generate service <caminho>                                                => Necessário para conectar Angular com rails

---------------------- >asdf ----------------------------------------

Maneger version Framework

asdf plugin add <name>                                                       => Adicionar plugin
asdf plugin list                                                             => Mostrar lista de plugins 
asdf plugin update --all                                                     => Atualizar todos os plugins
asdf plugin remove <name>                                                    => Você pode remover plugins
asdf install <name> <version>                                                => Instalar uma especifica versão da ferramenta instalada 
asdf install <name> latest                                                   => Instalar a última versão estável
asdf list <name>                                                             => Lista as versões instaladas
asdf list all <name>                                                         => Listar todas as versões de uma ferramenta 
asdf global <name> <version> [<version>...]                                  => Setar a versão no computador.
asdf shell <name> <version> [<version>...]
asdf local <name> <version> [<version>...] 
asdf current <name>                                                          => Ver a versão corrente instalada de uma certa linguagem. 

sudo apt-get install libmysqlclient-dev                                      => Ao realizar o bundle install mysql2 do rails pode dar erro sendo assim faça o seguinte instale esta lib

-------------------- >Bootstrap -------------------------------------

<div class="container-fluid"></div>                                          =>
<img class="img-responsive" />
<h2 class="text-center" />
<button class="btn btn-default"></button>
<button class="btn btn-default btn-block"></button>
<button class="btn btn-primary btn-block"></button>
"btn-danger"
"btn-info"
<div class="row"></div>
<div class="col-xs-4"></div>
<span class="danger"></span>
<span class="fas fa-thumbs-up"></span>  
<i class="fas fa-info-circle"></i>
<input type="text" class="form-control" placeholder="...<div>" required><div>
<div class="well"></div>


sass --watch node_modules/bootstrap/scss:node_modules/bootstrap/compiler     => ao empregar o bootstrap pelo node temos de compilar o código osx-ssl-certs

------------------------ >Docker ------------------------------------

** https://docs.docker.com/compose/rails/                                   => Esse tutorial é fundamental para criação de uma imagem ruby

** Por default temos de usar sudo para rodar o docker 
sudo apt-get remove docker docker-engine docker.io containerd runc              => Apagar versões antigas
sudo systemctl status docker                                                 => Status docker 
docker docker-subcommand --help                                              => Especifica um comando a ser usado e o descreve 
docker images                                                                => para vizualizar as imagens do seu pc
docker rmi ID_ou_nome_da_imagem                                              => Remover as imagens locais
docker search <nome_da_imagem>                                               => Pesquisar uma imagem online
docker ps -a                                                                 => Listar os containers em execução
docker rm Id_ou_nome                                                         => Remove o container em execução
Imagem                                                                       => -An image includes everything needed to run an application - the code or binary, runtimes, dependencies, and any other filesystem objects required.
docker pull ubuntu                                                           => Puxa a imagem oficial ubuntu
docker start 1c08a7a0d0e4<id_nome>                                           => Para iniciar um containeer parado
docker exec -it <id_nome> bash                                               => Retomar o container que foi inicializado 
docker stop quizzical_mcnulty<id_nome>                                       => Parando o docker em execução
docker run -i t ubuntu <id_nome>                                             => usar um tipo de container

docker build -t my_awesome_app .                                             => Ele executa o Dockerfile, gerando a imagem através do Dockerfile
ls


** Fato interessante nosso containers podem se transformar em imagens que podemos usar para gerar outros containers
docker commit -m "What you did to the image" -a "Author Name" container_id repository/new_image_name             => Criar uma imagem de um container    
docker commit -m "added Node.js" -a "sammy" d9b100f2f636 sammy/ubuntu-nodejs                                     => Um exemplo
exit                                                                         => sair do container 
docker ps -l                                                                 => mostra o último container criado
docker ps                                                                    => mostrar os container em execução
Control+P+Q                                                                  => Sai do terminal container que estava usando mas ainda o deixa executando 
docker attach <id_do_container>                                              => Como voltar a execução do conteiner
Control+V                                                                    => Saio do container e o mato (não funcionou comigo)
docker create <imagem>                                                       => Crio o container mais não o executo
docker pause <container_id>                                                  => Consigo pausar o container
docker unpouse <container_id>                                                => despausando o container
docker stats <container_id>                                                  => Mostra o quanto o container consome isso se ele estiver em execução
docker logs <commainer_id>                                                   => Motra logs ( comandos usados )
docker top <container_id>                                                    => Mostras mais dados do container


docker run -it --rm --user "$(id -u):(id -g)" -v "$PWD":/usr/src/app -w /usr/src/app rails rails --skip-bundle new my_new_app
	
Docker-compose

** Para abrir o terminar interatirativo no docker-compose

docker-compose exec web sh 

** Você poderá rodar um container 

docker-compose run web bash

------------------------ >Git --------------------------------------- 


git stash                                                                     => Irá salvar em cache as alterações não comitadas possibilitando a restauração depois
git stash pop                                                                 => restaura o cache com os arquivos modificados da branch 
git stash save -u 'Mensagem'                                                  => Criando um stash comentado
git fetch --all;git pull                                                      => Uma forma linear de dar fetch e pull

gitiginore -types                                                             => lista de todos os tipo Ruby rails node ....

npm i -g add-gitignore                                                        

gitignore rails                                                               => cria um gitignore para o projeto rails 
  
sudo apt-get install git 
git config --global user.name "myname "
git config --global user.email "myemail"
gti config --global --list                                                    => Listará todas as configurações git 
git config core.editor "nome vim ou nano ..."
git init
git status
git add arquivo                                                               => arquivo agora esta sendo rastreado Untracked file -> stage
git commit -m "Novo arquivo comitado"
git commit --message ""
git mv                                                                        => "The command to rename a file using Git is git mv"

git branch <nome>                                                             => Permite criar, listar, apagar e renomear ramificações
git branch -b  <nome> 
git branch -D  <nome>                                                         => 
git branch -m <nome>                                                          => renomear branch atual para nome 
git branch -a                                                                 => Listar todas as branchs remotas
git push origin --delete <nome>                                               => Excluir uma branch remota ( ou git push origin :<nome>)

git rebase origin master                                                      => Pesquisar ( Resolução de !reject  master -> master)

git push -f origin master                                                     => push forçado.
git push origin <branch> --force-with-leave                                   => Uma forma de realizar force não destrutivo, ou seja, se houver commits de outro 
git log                                                                       => mostrará os commits - verifica alteracoes realizadas
git remote                                                                    => ver a situação
git remote rm <name>                                                          => desfaz conexões
git remote rename <antigo> <novo>
git remote add upstream https or ssh                                          => setando o repositório remoto
git push -u origin master                                                     => Primeiro push em um repositório remoto
git push origin master                                                        => use para dar update nos seus arquivos remotos (Caso recebar erro: git push master --force ) 
git clone https...                                                            => Faz o clone do repositorio remoto em sua maquina
git commit -a -m ""                                                           => Envia as modificações para stage e faz o commit
git log --oneline                                                             => Mostra um historico resumido de modificações 
git log --pretty=oneline                                                      => Mostra histórico em uma linha.
git log --stat                                                                => Mostra histórico mais completo para sair aperte q
get log --oneline -S <Algo que se queira buscar>                              => Podemos fazer um search pelo log
git show <identifier>                                                         => Podemos selecionar um commit específicando seu identificador
git show e420911~1                                                            => Está sintaxe com que podemos utilizar um identificador para acessar seu parent ( use ~1 ou ~2)
git show :/Second                                                             => Podemos acessar um commit pode por meio do conteúdo de sua mensagem
git diff                                                                      => Faz a verificação que foi modificado no codigo
git diff <nome_do_arquivo>                                                    => Aponta para um arquivo especifico
gir diff --name-only                                                          => Mostra o nome dos arquivos que foram modificados.
git diff --staged                                                             => Faz a verificação até dos arquivos que estão staged, prestes a ser commitados
git blame                                                                     => Podemos por meio dele identificar quais usuários commitaram o que.
git rm index.html                                                             => Para descartar um arquivo após o comando ser dado o arquivo ira para área de stage aguardando ser commitado. Uma observação é que ele continuará no repositorio porém deletado.
git vm origem.html destino.html                                               => Mover ou renomear um arquivo
git checkout                                                                  => Desfaz mudanças que ainda não foram commitadas
git checkout -- <nome_do_arquivo>                                             => Retorna um arquivo para o estado do commit anterior. 
git reset                                                                     => Agora desfaz mudanças dos arquivos que já tiverem sido rastreados
git reset --hard  <identificador>                                             => Além de tirar o arquivo do stage também volta a seu estado original - Volta para o commit apontado sem constar no histórico.
git revert --no-edit "summet"                                                 => Não consegui aplicar
git config --global alias.co checkout                                         => Renomeando comandos.
git config --global credential.helper "cache --timeout=86400"                 => lembrando da senha.

git submodule add <url/do/repositório> <destino/do/submódulo>                 => Trabalho submodulos no git ( um repositorio dentro de outro )
git checkout HEAD~1                                                         => Depois de commitado podemos retornar um commit 


git reflog                                                                    => Com este comando vc poderá recuperar identificadores antes de um merge ou rebase. Com isso podemos usar um reset --hard para voltar ao estado deste commit apontado.
git reset < hash log > --hard                                                 => reseta a branch até a escolhida

git tag <nome_tag_para_commit>                                                => Podemos modificar o identificador de um commit por uma tag mais fácil de lido.( HEAD)
git tag <nome_tag_para_commit> <identificador>                                => Podemos também criar tags para commits antigos.
git tag -d                                                                    => Apagar tag
git tag -l                                                                    => Lista tags

(Como mostrar branch no terminal linux)
export PS1='\u@\h\[\033[01;34m\] \w\[\033[0;32m\]$(__git_ps1 " (%s)")\[\033[01;34m\]$\[\033[00m\] '   => Insirir no final do arquivo .bashrc arquivo homme
source ~/.bashrc                                                                                      => Execute no terminal o comando (salva o estado).
(Não esqueça de adicionar uma chave ssh no seu repositório remoto)

(Criando a chave pública e privada ssh)

ssh-keygen -o -a 100 -t ed25519 -f ~/.ssh/id_ed25519 -C "umemaildeRegistro@host.com"

ls -al ~/.ssh                                                                 => Veja se você já possui uma chave ssh

git commit --amend -m "Uma nova mensagem"                                     => reescrever o último commit, tem de haver cautela e nessa situação sem nenhum arquivo stage
git commit --amend --no-edit                                                  => O sinalizador --no-edit permite fazer a modificação no commit sem editar sua mensagem; 
** Ante adicione os outros arquivos que vc deseja commitar no stage 

git reset --soft HEAD~2                                                       => Eu reseto os commites que fiz até no meu penúltimo, porém não reseto os arquivos que fiz ou modifiquei.

git reset HEAD <nome_do_arquivo>                                              => remove um arquivo do stage também.
git reset HEAD *                                                              => Removendo todos os arquivos do stage.
git reset --hard HEAD~

git reset -- <nome_do_arquivo>                                                => remover um arquivo do stage, lembrar que há um espaço entre -- e o nome
git add -i                                                                    => com está opção vc pode fazer multiplaz inserções no stage sem usar git add . modo interativo
git add -p                                                                    => Em um mesmo arquivo com várias modificações posso distinguir os commits.

git rm -f --cached [<nome_arquivo]>                                           => Caso você venha a instalar um repositorio dentro de outro, sem querer, apagar o arquivo.git não é a única solução para que o arquivo deixe de ser um submodule você tem de limpar o cache.

git log --pretty=format:"%h - %an, %ar : %s"                                  => Conferir o log, mais bem detalhado
git log --pretty=format:"%h %s" --graph                                       => ver com uma estrutura de branchs

git push --set-upstream origin nova-branch                                    => fazem push direto no repositório de origem

git rm -rf --cached .                => Caso você tenha adicionado o gitignore depois do projeto criado. Remover cache.
git add .

git clean -n                         => Visualiza os arquivos untrackets que serão removido
git clean -f                         => Faz a remoção desses arquivos


---------------------------------- Git - Diogo  ----------------------------

git checkout <branch_name>                             => Switch Branch
git checkout -b <branch_name>                          => If Branch not exist, create and Switch
git branch -D <branch_name>                            => Delete that Branch
git push origin :<branch_name>                         => Delete Branch remotely
git add app/views/mobile/checkout/payment.html.haml    => Add file to commit
git commit -m "18534 - Adding terms check validation"  => Commit changes
git push -u                                            => Push and set upstream (only first push)
git push origin feature/18534-term                     => Push local files to Github
git pull origin feature/18534-relayout                 => Get new files of this Branch in remote
git merge --no-ff <branch-approved>                    => Merge <branch-approved> with current branch (commit merge)
git cherry-pick <commit SHA1>                          => Add specific commit at current branch
git rebase <branch>                                    => Reload specific branch on current branch (if was changed after created)
git reset --merge ORIG_HEAD                            => Undo merge that was not pushed to origin yet
git reset --hard HEAD~1                                => Back one commit
git reset --hard origin/<branch>                       => Reset local branch to remote branch
git checkout origin/master Gemfile.lock                => Reset specific file from master
git commit --amend -m "edit msg"                       => Edit last commit (if already pushed use -f) - mas antes podemos adicionar novos arquivos com add ai daremos o amend
git tag 1.55.1                                         => Create tag locally
git tag --delete 1.55.1                                => Delete tag locally
git push origin :1.55.1                                => Delete tag remotely
pull request (PR) direto pelo Github                   => Pull Request
git fetch --all                                        => Update all remotes locally but not upgrade the commits
git stash                                              => Save all different files temporary and remove from branch
git stash pop                                          => Revert git stash
git stash clear                                        => Delete all stashs
git show -s --format=%ci <commit>                      => Get time of commit were pushed
git --no-pager show <branch>:path/to/file              => Print content of file

git config --global user.name "Full Name"              => Set name of user
git config --global user.email "email@address.com"     => Set email of user 


--------------------------------- >Javascript --------------------------------------

Tag template                                          => Permite que você faça modificações em uma interpolação ( Template literal :) )  com uma função. e.g: acao`${variavel1} ${variavel2} e ${variavel3}`                     

Shorthand property                                    => Encurtar uma propriedade;

text.startSwicth("string")
text.endStwicth("string")
text.repeat(10)                                       => Repete o text 10 vezes.
text.includes("string")                               => verifica se um dada string está incluida no text.

Array.from("Jorge")                                   => ["J", "o", "r", "g", "e"]
Array.of(1, "jorge", {"idade": 23})                   => Juntar vários tipos e transformar em um array;

[1,2,3,4,5,5].find( x => x > 3)                       => 
[1,2,3,4,5,6].findIndex( x => x < 5)                  => Pergará o primeiro index de correspondencia;

(new Array(70)).fill(<um_valor>)                      => pesquisar é interessante, pode ser passado o intervalo Array.fill('string', 2, 57)

Destructuring in Arrays                                 

const arr = ['Jorge', '24', 'estudante', 'autonomo'];

const [name, idade, situacao , profissao] = arr       => Assim podemos fazer o destructing no arr onde name === "Jorge" sem precisar chamar pelo index arr[0]

[a,b] = [b,a]                                         => #Swap destructuring é interessante podemos fazer trocar sem precisar usar uma variável auxiliar;

console.log([..."jorge"])                             => Podemos é mapear um tipo iterável com spread e desmembra-lo com o spread operator. ficario ['j','o','r','g','e']

REST params é diferente de spread                     => fixa isso.

for ... of                                            => Esse loop é como se fosse o in do python com loops que pode ser dado braek para finalizar a iteração;

new Proxy()                                           => Mudar o coportamento de um objeto, ficar ali no meio meio modificando lembra o interceptor do axios;

new Set()                                             => trata de valores únicos

new WeakSet()                                         => Ao contrário do Set o WeakSet não aceita tipos primitivo apenas podemos passa objetos; Não é iterável :( mas para o caso de guardar objetos únicos


new Map()                                             => Parece com hash do ruby com métodos próprios {'kes' => value}

new WeakMap()                                         => Só aceita objetos;

padStart                                              =>
padEnd                                                => padEnd(<numero de caracteres>, <caracteres para completar>)

Object.entries                                        => Podermo pegar atributos e valor de um objeto e transformar um array > Object.entries(obj)

Object.values                                         => Retorna os valores do objeto.

Trailling Comman                                      => Vírgula no final de parametros de funções function test( a, b, ){}   para não quebrar o programa é algo opcional.

Anonymous closure                                     => Modos de criar um módulo

(function (){
  
})();

const myModule = (function () {})();                  => Outra forma de criar modularidade;

Comminjs                                              => module.export = <modulo>      e    no destino require(<modulo>)




// /**/                                               => Comentário de uma linha e comentário para múltiplas linhas
=                                                     => recebe ( atribuição )
null                                                  => nulo
var                                                   => identificador
let                                                   => identificador 
`String`  - "String" - 'String'                       => String, forma de escrever strings
Infinity 
NaN                                                  
object                                      
typeof <name>                                         => retorna o tipo
+                                                     => concatenação
Number.parseInt(n)                                    => converter para inteiro
Number.parseFloat(n)                                  => converter para float 
Number(n)                                             => Uma forma nova ( 2019 ) o motor quem decide
JSON.parse()                                          => Converter um JSON em objeto. 
`Placeholder ${ variável }.`                          => Desta forma podemos interpolar variáveis
s.length                                              => Comprimento da string 
<string>.toUpperCase()                                => Tornar para maiusculo
<string>.toLowerCase()                                => Tornar para minusculo
document.write()                                      => Output no Browser ( Imprimi uma string no browser ) 
<variável>.toLocalString('<string>', {style: 'value', currenty: 'RS'} )                         => Nesse caso é um exemplo de fazer modificação monetária ( Real, Dolar, etc ...)
var <nome> *=, %= , **=, /=, -=, +=                   => Essa sintaxe é válidada de atribuição
<, >, >=, <=, ==, !=                                  => Relacionamentos com retorno booleano
===                                                   => Operador de igualdade restrita ( avalia o tipo também )
&&                                                    => Conjunção
!                                                     => Negação
||                                                    => Disjunção 

<string>.trim()                                       => Exclui os espaços vazios de inicio e final;


let variavel = () => expressão;                       => Uma arrow function nada mais é que uma função anônma simplificada. Curioso é que podemos omitir os parenteses caso tenha apenas uma variável a usarmos.



DOM                                                   => Document Object Model 
window -> location/document/history -> html -> head/body -> tags                 => árvore DOM
getElementsByTagName('p')[0];                         => Selecionar o parágrafo da posição 0     var texto = window.document.getElementsByName('<tag>')[<posição>];
document.write(p1.innerText);                         => podemos inserir o paragrafo capturado um uma nova frase com o innerText.
innerHTML                                             => insere também as tags filhas além do texto
getElementById[ ]                                     => Seleciona um seletor id 
getElementsByName()                                   => 
var nome = querySelector(#id)                         => seleciona um id ou class 
querySelectorAll(.class)                              => 
nome.style.background()                               => Podemos mudar o estilo diretamente
window.prompt                                         => retorna uma string
window.alert                                          =>
window.confirm                                        => 
<var>.addEventListener('evento', função)              => Carrega o evento internamente no js
mouseenter                                            => inline é onmouseenter, onclixk  
mouseover                                           
mousemove                  
mouseout           
mousedown
mouseup 

(?=[A-Z])                                             => Regex

randomIndex: Math.floor(Math.random() * 20)          => Random method


ECMA 

Object.freeze(<name_variable>)                        => Torna uma variável imutável, ou seja, não se poderá edita-la ( const <nome_da_variável> não à torna imutável)



--------------------------                            => Usando addEventListener com React

class MyComponent extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      message: ''
    };
    this.handleEnter = this.handleEnter.bind(this);
    this.handleKeyPress = this.handleKeyPress.bind(this);
  }
  // change code below this line
  componentDidMount() {
      document.addEventListener('keydown', this.handleKeyPress)
  }
  componentWillUnmount() {
    document.removeEventListener("keydown", this.handleKeyPress) 
  }
  // change code above this line
  handleEnter() {
    this.setState((state) => ({
      message: state.message + 'You pressed the enter key! '
    }));
  }
  handleKeyPress(event) {
    if (event.keyCode === 13) {
      this.handleEnter();
    }
  }
  render() {
    return (
      <div>
        <h1>{this.state.message}</h1>
      </div>
    );
  }
};
-------------------------
  
D3

d3 
select()
append() 
text() 
selectAll()
attr()
style()
enter()
append('svg')
append('react')

-----------------------------

 document.addEventListener('DOMContentLoaded', function(){})                        ** Destas forma estamos inspecionando nosso interface para que qualquer evento ocorrido seja tratado pelo DOMContentLoaded; JSON API and  AJAX

-----------------------------

debugger                                                                            ** Escreva debugger em seu código que você poderá depurar no console do navegador.  

new RegExp(req.query.nome , "i" );                                                  ** Transformando uma string em regex;

window.location.href = "/<rota>"                                                    ** Assim você poderá mudar de página usando JS;

------------- Husky - editorconfig - Mocha - Chai - eslint - Coverage ( nyc um superset do Istambul.js ) ---------------------------

Common.js                                                     ** uma observação é o uso de importação nas versões antigas do ECMA não possuem esse recurso o que no obriga a utilizar a lib common.js ( require e module.exports ) mas nas versões na versão mais nova temos o import no js. Instalamos o Babel para fazer a transpilação desse código o que no possibilita empregar em desenvolvimento com browser que usam verões antiga.        

describe('<Nome da Classe>', function(){})                    ** descreve os testes de certo arquivo

context('Caso 1', function(){})                               ** separar caso de teste

it('should happen bloco', function(){})                       ** teste atômico

"test": "./node_modules/mocha/bin/mocha ./tests/**/*.spec.js" ** Executado npm test 

npm test -- --reporters                                       ** dará erro rsrs está desatualizado não há mais esse comando 

./node_modules/mocha/bin/mocha -R nyan ./tests                ** Mas com essa flag funciona com um gatinho.

npm test -- --bail                                            ** flag que executa os testes até o primeiro erro acontencer

context.only("", function(){})                                ** rodar apenas um bloco

context.skip("", function(){})                                ** pular um teste torna-lo pendenting

before(function(){})                                          ** Hook antes
after(function(){})                                           ** Hook depois
beforeEach(function(){})                                      ** Hook antes de cada
afterEach(function(){})                                       ** Hook depois de cada

var expect = require('chai').expect                           ** Importar o chai para o projeto para adição dos asserts

"test:tdd": "./node_modules/mocha/bin/mocha ./tests/**/*.spec.js --watch" ** Modificação de package.json para utiliza o hot reload

Smoke test   => expect('test').to.be.a('array')               ** testes de tipo

./node_modules/.bin/eslint src/*.js                           ** rodando o eslint

"test:coverage": "nyc npm test"                               ** usando o coverage

npm run test:coverage                                       ** executará o covarage 

** vamos fazer com que o código não possa ser subido para o github caso seu coverage seja menor que uma dada porcentagem:

'nyc': {
  "lines": 80,
  "functions": 80,
  "check-coverage": true  
}

 "husky": {
   "hooks": {
     "pre-push": "npm run lint && nyc npm test"
   }
 }

 npm install --save-dev @babel/core @babel/node               ** Lembra do babel-node você pode transpilar um código e o emprega-lo;

-------------------- >Heroku -------------------------

sudo snap install heroku --classic
heroku login
heroku create
git push heroku master                                => Fazendo deploy de projeto
heroku open                                           => Irá abrir sua URL
heroku logs --tail                                     => Acessando log
heroku ps                                             => verifica os dyno de sua aplicação free
heroku local web                                      => estou rodando o server pelo heroku e a sua porta é a 5000 ( localhost:5000)
heroku local                                           =>
heroku addons:open <name_app_base_addon>              => dados de seu plano para a aplicacao
heroku run rails console                              => carrega um console rails heroku ( um console remoto )
heroku run bash                                       => bash do servidor
heroku config:set <exemplo - TIMES=10>                => Setar algo na env, você utilizará essas configurações na produção
heroku config                                         => ver as configurações 

heroku pg:psql                                        => heroku dbconsole
heroku run rake db:migrate                            => faz a migração para o banco de dados heroku

echo $DATABASE_URL                                    => Irá motrar o caminho do banco definido pelo usuário ( remoto server)


-------------------- >Mac -----------------------------





-------------------- >MongoDB -------------------------

https://docs.mongodb.com/manual/tutorial/install-mongodb-enterprise-on-ubuntu/                   => Instalação

SQL                              Mongo

database                         database
table                            collection
row                              document ou BSON document
column                           field
index                            index
table join                       References ou embedded documents


Mongo terminal 
sudo mongod --dbpath /data/db                         => Rodo o Mongo
sudo mongo                                            => Abro o shell mongo
show dbs                                              => Irá mostrar os bancos de dados criados
use <nome_banco_de_dados>                             => Apontar para um banco de dados
db.createCollection('nome_da_collection')             => Criar um collection ( é como se fosse criar uma tabela)
show collections                                      => mostrar as collections em uso.
db.<nome_do_collection>.find()                        => Fazer uma busca de dados e todos o documentos da collection 
db.<nome_do_collectio>.insert({})                     => inserir uma linha
db.<nome_do_collection>.save()                        => tem a mesma funcionalidade do insert
db.<nome_do_collection>.update()                      => Faz atualização de uma linha.  e.g = db.checklist.update({name: "Original"},{name: "Atualizado"})
db.<nome_do_collection>.delete()                      => Apaga uma linha especificada.
db.<nome_do_collection>.insertMany([{},{}])           => Podemos criar múltiplas linhas dentro de um collection de uma vez só;
db.task.insertMany([{"name": "Preparar o café", "done": true, checklist: ObjectId("5f6a6a09be8e95201b4fb45a")},{"name": "Ligar a TV", done: true, checklist: ObjectId("5f6a6a09be8e95201b4fb45a")}])

db.<nome_do_collection>.find().pretty()               => Torna o retorno da query mais legível.
db.<nome_do_collection>.aggregate({$lookup: {from: "<nome_do_collection_referenciado>", localField:"_id", foreignField:"<nome_do_collection>", 

MongoDB Enterprise > db.checklist.aggregate({$lookup: {from: "task", localField: "id", foreignField: "checklist", as: "task"}}).pretty()


as:<nome_do_collection_referenciado>}}).pretty()       => o aggregate e $lookup realizam buscas mais complexas 
db.<nome_do_collection>.drop()                         => função de deletar;
db.checklist.deleteOne({ name: "Minha checklist" })    => deleta um documento

**Solução de error no MongoDB**                        => Caso o banco tenha sido derrubado 


~$ sudo service mongodb stop

~$ sudo rm /var/lib/mongodb/mongod.lock

~$ sudo mongod --repair --dbpath /var/lib/mongodb

~$ sudo mongod --fork --logpath /var/lib/mongodb/mongodb.log --dbpath /var/lib/mongodb

~$ sudo service mongodb start

** Para ter certeza de qual plataforma de sistema você usa se é systemd (which uses the systemctl)

ps --no-headers -o comm 1                              => no meu caso é systemd

** Problema: Se você não conseguir dar start no seu banco de dados mongo. Active: false

Geralmente é um erro de permissão para uso da porta adequada ( TODO: Pesquisar mais a respeito ) = https://askubuntu.com/questions/884541/cant-start-mongodb-service 

sudo chown -R mongodb:mongodb /var/lib/mongodb 
sudo chown mongodb:mongodb /tmp/mongodb-27017.sock

Suponha que você startou seu mongodb pelo docker-compose sendo assim você poderá realizar
o acesso ao mongo especificando uma porta

mongo --port 27017

-------------------- >MySQL - SQL----------------------

sudo apt update                                  ** update system 
sudo apt install mysql-server -y                ** instalação da última versão do mysql ( sudo apt install mysql-server )
  sudo systemctl status mysql.service              ** vericação de "active server"
sudo mysql_secure_installation_                  ** instalação de segurança

sudo systemctl start mysql.service               ** inicializando o servidor
 mysqladmin -u root -p shutdown                  ** parar conexão.
ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'                   ** Encontrar o endereço de ip público do seu servidor

mysql -u root -p nome_da_database                ** Acessa o banco

sudo apt-get install apache2                     ** Instalação do apachi
localhost/                                       ** Acessando o apachi no browser

sudo add-apt-repository ppa:ondrej/php           ** primeiro passo na instalação do php7 ( Adição do repositorio do php7)
sudo apt-get update                              ** dar um update

sudo apt-get install apache2 php7.0-common php7.0-cli php7.0 libapache2-mod-php7.0                              ** Instalação do php7

p
create table comclien_bkp as( select * from comclien where c_estaclien = 'SP');                                 ** Basicamente estou criando uma tabela com atributos de outra 


** Configuração do php para apontar para rota específica 
sudo nano /etc/apache2/mods-enabled/dir.conf

Modifique para:  DirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm

sudo systemctl restart apache2                    ** reiniciar o servidor web 
service mysql status
sudo service mysql stop


use database_that_you_want                        ** use é o comando que carrega a database para ser consultada 

> Criando um novo usuário 

create user usermysql@'%' identified by 'cursomysql';

> Quando utilizamos o % em nosso código, estamos dizendo que este
usuário poderá acessar o nosso banco a partir de qualquer host. Poderíamos
ter limitado ao acesso do local apenas, substituindo o % por localhost .
Ele já está criado, porém não tem nenhuma permissão. Como não precisa-
mos limitá-lo, vamos conceder direito total a ele. Faremos isso com o seguinte
comando:

grant all privileges on *.* to usermysql@'%'
with grant option;

> Mas se quisessemos revogar:

revoke all on *.* from usermysql;


COMMANDS

SHOW DATABASES;                                  => Mostrar os DATABASES
CREATE TABLE nome_tabela ( column1, column2);    => 
DROP TABLE nome_tabela
USE name_dataTable                               => Setando um banco de dados
CHAR - VARCHAR - INT - BLOB - DEC - DATE - DATETIME => Tipos de dados 
DESC nome_da_tabela                              => Mostra o nome das colunas de uma dada tabela.

ALTER TABLE nome_da_table
ADD coluna_nome dateType;

ALTER TABLE nome_da_table
DROP COLUMN coluna_nome;
 
CREATE TABLE nome_tabela(                        => Invalidando Nulos
  nome VARCHAR(30) NOT NULL
);

CREATE TABLE nome_tabela(
  nome VARCHAR(30) DEFAULT 'McLovin'
);

SELECT * FROM nome_da_tabela 
WHERE coluna IS NULL;                            => Forma de mapear campos nulos.

'_' e '%'                                        => São caracteres coringas para LIKE 

SELECT * FROM nome_da_tabela
WHERE coluna LIKE '%' OR coluna2 LIKE '_exto'    => O underscore é para completar um caracter e o % é intervalo.

SELECT * FROM nome_da_tabela
WHERE column BETWEEN numero_tal AND numero_outro => Utilizando intervalos.

IN and NOT IN                                    => Avaliando conjunto de valores.

SELECT * FROM nome_tabela
WHERE NOT column LIKE 'valor';                   => Implementando NOT há uma tabela.

DELETE FROM nome_tabela WHERE column = tal_valor => Deleta um registro procurado

UPDATE nome_da_tabela                            => Empregando o UPDATE
SET coluna_tal = novo_valor
WHERE nome_de_uma_coluna = dado_valor;

UPDATE nome_da_tabela                            => Podemos transformar em letras maiusculas empregando o UPPER() e LOWER()
SET UPPER( coluna_varchar_tal )
WHERE nome_de_uma_coluna = dado_valor_pesquisado;

SHOW CREATE TABLE nome_da_tabela;                => Irá listados os atributos de quando a tabela foi criada.

CREATE TABLE lynn_contatos (
  id_contato INT NOT NULL AUTO_INCREMENT,
  sobrenome varchar(40) DEFAULT 'McLovin',
  primeiro_nome varchar(30) DEFAULT NULL,
  email varchar(50) DEFAULT NULL,
  aniverdario date DEFAULT NULL,
  profissao varchar(30) DEFAULT NULL,
  local varchar(40) DEFAULT NULL,
  estado_civil varchar(20) DEFAULT NULL,
  interesses varchar(100) DEFAULT NULL,
  procura varchar(100) DEFAULT NULL,
  sexo char(1) DEFAULT NULL,
  PRIMARY_KEY (id_contato)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci 

ALTER TABLE lynn_contatos 
ADD COLUMN id_contato INT NOT NULL AUTO_INCREMENT FIRST, 
ADD PRIMARY KEY (id_contato);

> Além de first podemos uma outras palavras chaves como BEFORE, AFTER, LAST, ... ( SECOND e THIRD ? ) 

ALTER TABLE nome_tabela
ADD COLUMN nova_column dataType SECOND;

ALTER TABLE nome_tabela
ADD COLUMN nova_column dataType
AFTER outra_coluna;

ALTER TABLE nome_tabela                            => Editando nome da tabela
RENAME TO novo_nome_tabela; 

ALTER TABLE nome_tabela                            => Podemos alterar o nome de uma coluna 
RENAME COLUMN antiga_coluna_nome TO novo_nome,
RENAME COLUMN antiga_outra_coluna_nome TO novo_nome_outra; 

ALTER TABLE nome_tabela             => Com a palavra chave CHANGE além de modificar o nome podemos modificar os tipos.
CHANGE COLUMN antiga_coluna nova_columa dataType_novo; => nesse deve ter `antiga_coluna nova_columa`

ALTER TABLE nome_tabela             => Usando o change para altera apenas o tipo de uma coluna;
CHANGE coluna_tal datatype_novo;

ALTER TABLE nome_tabela             => Com a palavra chave MODIFY podemos alterar apenas os tipos de dados
MODIFY COLUMN nome_da_coluna dataType_novo;

ALTER TABLE sua_tabela              => Podemos remover a chave primária 
DROP PRIMARY  KEY;

Podemos ter apenas um campo autoIncremente por tabela.

INSERT INTO lynn_contatos( sobrenome, primeiro_nome, email, telefone, aniversario, profissao, local, estado_civil, interesses, procura, sexo, altura ) VALUES(
  'Briethly',
  'Lynn',
  'lynn@lynn.com',
  '212222222',
  '1996-10-21',
  'escritor',
  'sao francisco, CA',
  'casada',
  'leitura series cinema',
  'felicidade',
  'F',
  1.80
);

SELECT COUNT(*)                    => retorna o tamanho da tabela
FROM nome_da_tabela 

Manipulando String com SQL 

SUBSTRING_INDEX(sua_linha_de_texto, posicao inicial, tamanho)   => Fornece parte de uma linha de texto;

SUBSTR(sua_coluna_registro, index_inicio_que_desaja_captura)

UPPER() e LOWER()  => São conhecidos

REVERSE(sua_linha_de_texto)                               => É isso mesmo um sort invertido

LTRIM() e RTRIM()                                         => Remove espaços vazios das strings

LENGTH()                                                  => Retorna o número de caracteres de uma linha

SELECT local
FROM nome_da_tabela

TRIM                                                      => Podemos usar TRIM para fatiar os dados

UPDATE meus_contatos SET interesses = TRIM(RIGHT(interesses, (LENGTH(interesses)- LENGTH(interesses2)-1)));

UPDATE lynn_contatos
SET estado = RIGHT(local, 2)            # CA
SET cidade = SUBSTRING(local, ',', 1);  # sao francisco, irá retornar o que há após a vírgula

Usando o CASE 

UPDATE minha_tabela

SET nova_coluna =  
  CASE 
    WHEN coluna1 = valor1 # quando ess condição é satisfeita nova_coluna é atribuida.
      THEN novovalor1     # valor setado
    WHEN coluna2 = valor2 # quando ess condição é satisfeita nova_coluna é atribuida.
      THEN novovalor2
  ELSE novovalor3
  END; 

Podemos colocar o WHEN e THEN em mesma linha;

Usando o ORDER BY para ordernar alfabeticamente:

SELECT titulo, categoria
FROM tabela_filme
WHERE categoria = 'familia'
ORDER BY titulo;  # Podendo usar ASC e DESC

SELECT SUM(venda)
FROM tabela_vendas
WHERE data_inicial = 1996-21-10;  

SELECT primeiro_nome, SUM (venda)
FROM venda_biscoito
GROUP BY primeiro_nome
ORDER BY SUM (venda) DESC;  => Um agrupamento realizado por nome e destacando a soma das vendas.

SELECT primeiro_nome, AVG (venda)
FROM venda_biscoito
GROUP BY primeiro_nome;

SELECT primeiro_nome, MAX (venda) # seleciono os valores máximos de cada group 
FROM venda_biscoito
GROUP BY primeiro_nome;

SELECT DISTINCT data_venda
FROM venda_biscoito
ORDER BY data_venda;

SELECT COUNT( DISTINCT data_venda)
FROM venda_biscoito;

SELECT name, SUM(venda)
FROM venda_biscoito
GROUP BY name
ORDER BY SUM(venda) DESC
LIMIT 1,1;                         # Usando-se do limit podemos estar restringindo o número de resgitros retornados da tabela.

LIMIT  # pode ser utilizado com a passagem de um parâmetro ou de dois. Com um aparecerá a quantidade de registros que foram passados e com dois temos o primeiro parâmetro como ponto de início e o segundo quanto ao registro final ( iniciando em 0 );

CREATE TABLE interesses(
  id_inter INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
  interesse VARCHAR(100) NOT NULL,
  id_contato INT,
  CONSTRAINT lynn_contatos_id_contato_fk 
  FOREIGN KEY (id_contato)
  REFERENCES lynn_contatos (id_contato)
);

Integridade Referencial - Constraint
Dependencia Funcional
Chave Priméria composta
Dependência Transitória

> Possuem a mesma função de modo diferentes 

  CREATE TABLE profissao(
    id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
    profissao VARCHAR(20)
  );
    INSERT INTO profissao (profissao)
    SELECT profissao FROM tabela_que_quero_dados
    GROUP BY profissao;
    ORDER BY profissao;

  CREATE TABLE profissao AS 
    INSERT INTO profissao (profissao VARCHAR(20))
    SELECT profissao FROM tabela_que_quero_dados
    GROUP BY profissao
    ORDER BY profissao;

  ALTER TABLE profissao
  ADD COLUMN id INT NOT NULL AUTO_INCREMENT FIRST
  ADD PRIMARY KEY id;

  CREATE TABLE profissao
  (
    id INT NOT NULL AUTO_INCREMENT PRIMARY KEY PRIMARY KEY,
    profissao VARCHAR(20)
  ) AS

  INSERT INTO profissao (profissao)
  SELECT profissao FROM tabela_que_quero_dados
  GROUP BY profissao
  ORDER BY profissao;

Conexão Interna - utilizando-se do JOIN # Basicamente é um conexão cruzada com alguns resultados removidos por uma condição de consulta.

* Esse primeiro exemplo é um cenexão cartesiana tabela_tal X tabela_tal

  SELECT b.brinquedo, g.garoto
  FROM brinquedo AS b
  CROSS brinquedo AS b
  CROSS JOIN 
  garotos AS g;

  SELECT briquendos.brinquedo, garotos.garoto FROM brinquedo, garoto # Faz o mesmo BLZ.


Conexões internas - Parte 2 podemos realizar o seguinte introduzindo conexões INNER JOIN

  SELECT tabela1.coluna, tabela2.coluna 
  FROM tabela1
    INNER JOIN 
    tabela2
  ON uma_condicao; # o where pode ser empregado aqui;

Conexões com equijoin - podemos iqualar chaver primarias e estrageiras de tabelas achando um resultado cruzado.

  SELECT tabela1.coluna_tal, tabela2.coluna
  FROM tabela1
    INNER JOIN
    tabela2
  ON tabela1.id_tabela = tabela2.id_tabela

Conexões não-equijoin - Combinando registros que possuem chave estrangeira e primaria de outra tabela diferentes. Conexões internas que testam desigualdade.

  SELECT tabela1.coluna_tal, tabela2.coluna
  FROM tabela1
    INNER JOIN
    tabela2
  ON tabela1.id_tabela <> tabela2.id_tabela

Conexão Natural - Parece muito com uma conexão interna equijoin contudo com a condição definida da iqualdade entre chaves ( estrangeira e primária ).

  SELECT tabela1.coluna_tal, tabela2.coluna
  FROM tabela1
    NATURAL JOIN
    tabela2

Adicionando uma constraint 

ALTER TABLE tabela_tal
add CONSTRAINT tabela_tal_com_tabela_tal_fk
foreign key (coluna_associadla)
references com_tabela_tal (coluna_associada)
on delete no action
on update no action;

alter table comivenda drop foreign key 
tabela_tal_com_tabela_tal_fk;

SELECT c_codiclien, c_razaclien
FROM comclien
WHERE n_numeclien IN (1,2);               # Utilizando a instrução IN para consultar um intervalo

SELECT c_codiclien, c_razaclien
FROM comclien
WHERE n_numeclien NOT IN (1,2);            # Utilizando a instrunção de não contido


> Aqui temos uma alternativa ao Join com sub consulta, não é recomendado tem
pouca performance além disso o código não fica muito legível.

SELECT c_codivenda Cod_Venda,
	(SELECT c_razaclien
	FROM comclien
	WHERE n_numeclien = comvenda.n_numeclien) Nome_Cliente
FROM comvenda;


> No caso do join podemos utilizar de um meio mas informal e comum

SELECT c_razaclien, c_codivenda Cod_Venda
FROM comvenda, comclien
WHERE comvenda.n_numeclien = comclien.n_numeclien;

> Há também a forma mais formal de ser realizada 

SELECT c_codiclien codigo, c_razaclien razao_social, c_codivenda codi_venda
FROM comvenda
	join comclien on
	comvenda.n_numeclien = comclien.n_numeclien
order by c_razaclien;

> Como fazer um agrupamento com um join 

SELECT c_codiclien, c_razaclien
	FROM comclien, comvenda
	WHERE comvenda.n_numeclien = comclien.n_numeclien
group by c_codiclien, c_razaclien
order by c_razaclien;

> Podemos fazer a contagem de cada registro agrupado:

SELECT c_codiclien, c_razaclien, count(n_numevenda) Qtde
	FROM comclien, comvenda
	WHERE comvenda.n_numeclien = comclien.n_numeclien
group by c_codiclien, c_razaclien
order by c_razaclien;

> Usando a cláusula having count()

SELECT c_razaclien, count(n_numevenda) AS numero_de_vendas
FROM comclien, comvenda
WHERE comvenda.n_numeclien = comclien.n_numeclien
group by n_razaclien
HAVING numero_de_vendas > 2; # ou having count(n_numevenda) > 2;

> Podemos usar CONCAT () para termos a concatenação de registros

SELECT concat(c_razaforne,' - fone: ', c_foneforne) AS concatenacao
FROM comforne;

> Com o CONCAT_WS() podemos definir um separador entre os registros

select concat_ws(';',c_codiclien, c_razaclien, c_nomeclien)  # o primeiro parâmetro define o separador
from comclien
where c_razaclien like 'GREA%';

> ALGUMAS FUNÇÕES DE CÁLCULO 

ROUND para arredondamento:

select round('213.142',2)
from dual;

FORMAT para formatação:

select format('21123.142',2) from dual;

TRUNCATE para arredondar também

select truncate(max(n_totavenda),0) maior_venda
from comvenda;

Sqrt() obter o quandrado

select sqrt(4);

pi(), sen(), cos(), tan()



--------------------------- > Next ----------------------------

Como iniciar um projeto next.js

Instalando

asdf plugin-add nodejs
sudo apt-get install gpg
bash ~/.asdf/plugins/nodejs/bin/import-release-team-keyring
asdf install nodejs 15.0.1
asdf global nodejs 15.0.1
node -v

* Instalando o Yarn 
   npm install --global yarn

* Create-next-app
   npm i create-next-app

* Criando um projeto
   npm create-next-app web

* Instalando o Typescript
   yarn add @types/node
   yarn add typescript @types/react

TypeError: Class extends value undefined is not a constructor or null

Caso tenha esse error remove seu arquivo node-modules e reinstale com npm i;  

Sharp Module Installation Error

npm config set ignore-scripts false
rm -rf node_modules
npm install


--------------------------- >Node.js --------------------------

sudo apt intall node.js
.exit                                             => Sair do terminal de comando node 
console.log()                                     => Output ( printar um valor )
typeof                                            => retorna o tipo  ( JS )
<number>.tofixed(numero de casas )                => comando que muda o número de casas depois da virgula  
<number>.tofixed().replace('.',',')               => o replace faz a conversão de uma string em outra              
sudo apt install npm

Rails - Crie um arquivo especificando a nvm apontando o node que está sendo utilizado
touch .nvmrc 

process                                           => É uma biblioteca interna do node que podemos usar para acessar dados enviados do usuário require('process')

process.stdout.write()                            => Escrever algo no terminal
process.stdin.o('data', entrada => { })           => Pdemos capturar os caracteres digitado pelo usuário
process.exit()                                    => Método que força a saida do dado
fs                                                => Com esta biblioteca podemos criar, excluir, renomear e atualizar arquivos
fs.writeFile(<name_arquivo>,<dados_internos>, err => { console.log(err)})    => Como gerar um arquivo
fs.rename(<name_antigo>,<name_novo>)                                         => Renomear um arquivo
fs.appendFile(<name_arquivo>,<novos_dados>, err => { console.log(err)})      => Acrescentando dados à um arquivo antigo
__dirname                                                                    => Variável de ambiente que aponta o caminho do diretório
fs.unLink(<name_arquivo>, err => { console.log(err)})                        => Deleta um arquivo

http                                                                         => Biblioteca que possibilita a criação de um server
const server = creatServer((req,res) => {})                                  => req é a requisição e res é a resposta
req.method                                                                   => Informará qual verbo está sendo empregado
req.url                                                                      => Retornará a url passada
res.statusCode=200                                                           => Qual o status da paǵina, sendo 200 está tudo certo
server.listen(3000, () =>{})                                                 => Qual porta podemos estar acessando nosso server;

npm install express --save                                                   => Framework express
npm install nodemon --save-dev                                               => Pacote que salva as modificações sem necessitar restartar o server

snap install postman                                                         =>

chain of Resposibility Express                                               =>

Middlewares                                                                  =>

npm install mongoose --save                                                  => Intermediário MongoDB e Express(Aplicação)

** Não misture dado de controle com rotas.                                   

RESTFULL                                                                     => Um site que é API e site ao mesmo tempo.  

------------------------- >NPM ------------------------------

~/.npm/                                            => Caminho onde encontramos o packages 

https://github.com/nvm-sh/nvm                      => Instalação nvm.
nvm install node 
nvm ls-remote                                      => listarar todas as versões node
nvm use node                                       => Mostrar a versão em uso do node
nvm run node --version                             => Auto explicativo
nvm exec 4.2 node --version                        => Usar uma versão especifica do node
nvm which v14.5.0                                  => Descobrir o caminho da versão node especificada
nvm use system                                     =>
nvm ls                                             => Lista as versões
nvm run system --version                           => 
nvm alias default 0.11.13                          => Tornando uma versão node default
nvm use default                                    => apontando

npm root                                           => caminho npm
npm help update 
npm help config                                    => Ver documentação
npm init                                           => iniciar um projeto
npm init --yes                                     => cria um package sem as perguntas (pula as perguntas) ou apenas -y
npm config set init-author-name "<seu_nome>"       => Configurando nome default depois do npm init.
npm set init-license "MIT"                         => Configurando licensa default.
npm get init-license                               => Retorna "MIT"
npm delete init-license                            => Reseta as confirações init
npm install <nome_package>                         => Como baixamos packages
npm install <nome_package> --save                  => Acho que não há distinção com o de cima. ( Em tutoriais a distinção é "escrita automática no package.json")
npm install <nome_package> --save-dev              => Para ambiente de Desenvolvimento
npm uninstall <nome_package>                       => Desinstala a dependencia antes instalada
npm install <nome_package> -g                      => Instalando um package globally. (sudo)
npm list --global                                  => Listas os packages globais.
npm uninstall <nome_package> -g                    => Desinstalação da lista de package global (sudo)
npm install loadash@3.3.0 --save                   => Salvamos uma npm específica
npm update --dev --save-dev                        => Fazemos update de --dev --save-dev
npm install npm@latest -g    
npm install -g npm@latest -g                       => Update npm use sudo

npm addUser                                        => loggar o usuário da conta do npm no terminal com email e senha

npm install uglifyjs-webpack-plugin --save-dev     => webpack usa para definir apenas pacote em uso de modulo importado


transpilação com Babel - transpilar uma versão do ECMA em outra. Uma ferramenta que possibilita a compatibilidade de navegadores que não suportam determinada versão.

npm install @babel/core @babel/cli @babel/preset-env --save-dev  // um pacote que usamos apenas em desenvolvimento não em produção.( --save-dev)
npx babel <nome_arquivo_a_transpilar>                                                           => Gera um print do arquivo transpilado.
npx babel <nome_arquivo_a_transpisrclar> -o <nome_do_arquivo_de_saida>                             => Gera um novo arquivo com os dados do arquivo antigo transpilado
npx babel <nome_arquivo_a_transpilar> -o <nome_do_arquivo_de_saida> --presets=@babel/preset-env => a biblioteca que instalamos nos possibilita especificar a vesão de transpilação
babel.config.js                                                                                 => Para não precisar ficar execuntando --presets=@babel/preset-env crie o arquivo babel.config.js 

npx babel <nome_diretorio_a_ser_transpilado> --out-dir <nome_do_diretorio_de_saida>             => Além de Arquivos podemos transpilar diretórios inteiros. Podemo usar o --presets=@babel/preset-env

npx                                                                                             => npx pode ser configurado, pois é apenas uma atalho para


sudo npm install http-server --global                                                           => Pacote de mini servidor local

npm install --save-dev webpack webpack-cli                                                      => Instalação do webpack criando o arquivo src, O webpack é estático não se comporta como um server de inicio.

npx webpack --mode development                                                                  => Ambiente webpack de desenvolvimento para o webpack
npm install webpack-dev-server --save-dev                                                       => Mine servidor webpack para rodar a app.

npm install --save styled-components                                                            =>  
npm install react-star-rating-component --save                                                  => É um pacote que cria escala de avalição ( estrelas ).

npm install eslint --save-dev                                                                   => instalação de verificador de código
./node_modules/.bin/eslint --init                                                               => Iniciar o eslint em um projeto local ( Lembrar de não usa-lo globalmente)

testes Com Mocha e Chai

npm test                                                                                        => test setado no package.json
npm test -- --reporters                                                                         => tipos de visualiazações.

npm i gitignore -g                                                                              => Adicionando o gitignore a um projeto
gitignore --types                                                                               

-------------------------- Python--------------------------- 

Criar virtual venv 
      python3 -m venv .venv
    source .venv/bin/activate
      
Para desativar digite deactive.

python3 -m http.server


Pip

pip list
python -m pip install --upgrade pip                                                             => Algumas vezes um pacote pode não carregar por conta do pip estar desatualizado


----------------------------------------- >PostgreSQL ------------------------------------------------------------

Para a Instalaçãoão apenas veja o site oficial

pg_ctlcluster 11 main start                           ** Para iniciar o server
pg_ctlcluster 12 main start

pg_ctlcluster 12 main status                          ** Verifica se está rodando
sudo systemctl stop postgresql@12-main                ** Parar o banco
sudo systemctl start postgresql@12-main               ** Iniciar sever

sudo systemctl start postgresql

>> Nesse site você irá ver mas sobre roles e como realizar a instalção do postgresql
  - https://www.digitalocean.com/community/tutorials/how-to-install-postgresql-on-ubuntu-20-04-quickstart-pt 


psql --version                                        ** O psql é o programa de gerenciamento e uso do PostgreSQL pelo usuário local. 

createdb <noma_banco> -U postgres                     ** criar um banco
psql -l -U postgres                                   ** vizualizar o banco criado
dropdb <nome_banco> -U postgres                       ** Excluir o banco de dados indicado


sudo apt update

sudo apt install postgresql postgresql-contrib

rails new appname -d postgresql                      ** Iniciar um projeto rails com postgres

sudo -i -u postgres                                  ** Entrar, logo depois digita-se psql ( user)
sudo -u postgres psql

\l                                                   ** lista databases.
\du                                                  ** verifica a permissao de usuários
\d                                                   ** Mostra todas as tabelas de um certo banco de dados
\g                                                   ** fazer consulta
\?                                                   ** Ajuda comandos
\h <Nome_do_comando>                                 ** Ajuda comando

\c dbname username                                   ** Você acessar qualquer banco de dados passando o nome dele seu usuário
\dt                                                  ** Você conseguirar visualizar todas as tabelas desse banco
\d <nome_da_tabela>                                  ** Dessa forma você conseguirá acessar os atributos da tabela passada

\g                                                   ** SELECT version(); ( Mostrar a versão do postgres e dados do sistema)
\s                                                   ** Histório de comandos usados


DROP DATABASE <nome_do_banco_de_dados_a_ser_excluido> ** Excluir banco de dados


sudo -u postgres createuser -s pguser                ** Criar e setar um superuser



░██╗░░░░░░░██╗░█████╗░██████╗░███╗░░██╗██╗███╗░░██╗░██████╗░
░██║░░██╗░░██║██╔══██╗██╔══██╗████╗░██║██║████╗░██║██╔════╝░
░╚██╗████╗██╔╝███████║██████╔╝██╔██╗██║██║██╔██╗██║██║░░██╗░
░░████╔═████║░██╔══██║██╔══██╗██║╚████║██║██║╚████║██║░░╚██╗
░░╚██╔╝░╚██╔╝░██║░░██║██║░░██║██║░╚███║██║██║░╚███║╚██████╔╝
░░░╚═╝░░░╚═╝░░╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░╚══╝╚═╝╚═╝░░╚══╝░╚═════╝░

Se o server não estiver connectando com o socket 
Um erro como `connections on Unix domain socket "/var/run/postgresql/.s.PGSQL.5432"?`

É necessário reinstalar seu postgresql ( não necessáriamente só não sei resolver o problema )

1 - Verificar as dependencias de postgres

  dpkg -l | grep postgres 

2 - Logo depois iremos remover todo que houverem ( Exemplo ) 

  sudo apt-get --purge remove  pgdg-keyring postgresql-12 postgresql-client-12 postgresql-client-common postgresql-common

3 - Logo depois reinstale

Se você receber um erro de autenticação de senha você pode realizar esse processo 

FATAL: Peer authentication failed for user "postgres"

https://stackoverflow.com/questions/18664074/getting-error-peer-authentication-failed-for-user-postgres-when-trying-to-ge

----------------------------------------- PHP --------------------------------------------

sudo apt install php7.2-cli                            **Baixando php7

chmod 755 [o nome do executável]                       **Para a instalação do xampp ( dar permissão)
ls -l [nome  do executável]                            **Verificar permissões.
sudo apt install net-tools                             ** If occurred error.

sudo service apache2 status
sudo service apache2 stop
----------------------------------------- >VS Code --------------------------------------

Control + shift + P Output

control+space                                        ** Auto complete
html>body>div                                        ** Emmet sintaxe
control+shift+M                                      ** Abre um terminal
f5                                                   ** Debbuger
f12                                                  ** Vai para definição da sintaxe ( Parece um control + D)
control + click outro arquivo                        ** 
control + k + z                                      ** Modo sem distrações para sair aperte esc + esc 

Extensões - https://youtu.be/PsvtPr6cZtA

Materialize
Bookmarks                                            ** Marcação para se localizar no projeto
indent-rainbow                                       ** Extensão de visualização
pomodoro-timer
bracket-pair-color
git-lens
vscode-faker
TODO-parser
minify 
change-case
wakatime                                             ** Muito bacana
ruby on rails 
ruby-Rubocop
  gem install rubocop
  
Debuger

gem install ruby-debug-ide
gem install debase

Control + seta                                       ** Movimentação de cursor entre palavras

 
-------------------------- >Rails----------------------------- 

deploy 

https://m.do.co/c/4ede815c4ced




David Heinemeier Hansson - DHH

Docker compose e Rails 

document.addEventListener( 'turbolinks:load', function() {            ** Começo importante caso tenha de usar js em seu código 

logger.info("logger created".red)                                     ** Com a gem 'colorize' podemos fazer um debbug

./bin/webpack-dev-server                                              ** Rode o webpack ao mesmo tempo que sua aplicação 


> Crie um arquivo Dockerfile e insira:

  FROM ruby:2.5
  RUN apt-get update -qq && apt-get install -y nodejs postgresql-client
  WORKDIR /myapp
  COPY Gemfile /myapp/Gemfile
  COPY Gemfile.lock /myapp/Gemfile.lock
  RUN bundle install
  COPY . /myapp
  
  # Add a script to be executed every time the container starts.
  COPY entrypoint.sh /usr/bin/
  RUN chmod +x /usr/bin/entrypoint.sh
  ENTRYPOINT ["entrypoint.sh"]
  EXPOSE 3000
  
  # Start the main process.
  CMD ["rails", "server", "-b", "0.0.0.0"]

> Crie um arquivo Gemfile mas ele será sobrescrito quando o bundle for inicializado.

  source 'https://rubygems.org'
  git_source(:github) { |repo| "https://github.com/#{repo}.git" }
  
  gem 'rails', '~> 6.0.3', '>= 6.0.3.3'


> Crie um arquivo Gemfile.lock

> Crie um arquivo chamado entrypoint.sh e insira: Next, provide an entrypoint script to fix a Rails-specific issue that prevents the server from restarting when a certain server.pid file pre-exists. This script will be executed every time the container gets started. entrypoint.sh consists of:

  #!/bin/bash
  set -e
  
  # Remove a potentially pre-existing server.pid for Rails.
  rm -f /myapp/tmp/pids/server.pid
  
  # Then exec the container's main process (what's set as CMD in the Dockerfile).
  exec "$@"

> Crie o arquivo docker-compose.yml (https://docs.docker.com/compose/compose-file/): 

  version: "3.8"
  services:
    db:
      image: postgres
      volumes:
        - ./tmp/db:/var/lib/postgresql/data
      environment:
        POSTGRES_PASSWORD: password
    web:
      build: .
      command: bash -c "rm -f tmp/pids/server.pid && bundle exec rails s -p 3000 -b '0.0.0.0'"
      volumes:
        - .:/myapp
      ports:
        - "3000:3000"
      depends_on:
        - db

> Criando o projeto - First, Compose builds the image for the web service using the Dockerfile. The --no-deps tells Compose not to start linked services. Then it runs rails new inside a new container, using that image. Once it’s done, you should have generated a fresh app:

  docker-compose run --no-deps web rails new . --force --database=postgresql

> No caso de estamos em uma distruição linux devemos configurar as permições deste projeto, já que sua criação foi realizada pelo user root:

  sudo chown -R $USER:$USER .

> Por fim devemos construir a imagem novamente sempre que hover modificação no Gemfile. Now that you’ve got a new Gemfile, you need to build the image again. (This, and changes to the Gemfile or the Dockerfile, should be the only times you’ll need to rebuild.)

  docker-compose build 

> Nesse momento com o projeto já criado vamos configurar o banco de dados:

  default: &default
    adapter: postgresql
    encoding: unicode
    host: db
    username: postgres
    password: password
    pool: 5
  
  development:
    <<: *default
    database: myapp_development
  
  
  test:
    <<: *default
    database: myapp_test

> Vamos subir a aplicação agora, assim vc não precisará instalar tudo novamente:
  
  docker-compose up

> Vamos criar o bando de dados:
  
  docker-compose run web rake db:create

> If you make changes to the Gemfile or the Compose file to try out some different configurations, you need to rebuild. Some changes require only docker-compose up --build, but a full rebuild requires a re-run of docker-compose run web bundle install to sync changes in the Gemfile.lock to the host, followed by docker-compose up --build.

Here is an example of the first case, where a full rebuild is not necessary. Suppose you simply want to change the exposed port on the local host from 3000 in our first example to 3001. Make the change to the Compose file to expose port 3000 on the container through a new port, 3001, on the host, and save the changes:

  ports: - "3001:3000"

> Vamos fazer a atualização de nosso imagem sem Rodeio:
  
  docker-compose up --build

> Run rails console

docker-compose exec web rails console

> Instalando Docker-compose + rails 6 + mailcatcher + ruby 2.7.1

Errno::EADDRNOTAVAIL (Cannot assign requested address - connect(2) for "localhost" port 1025)

Um provável problema que você possa cair é este se não configurar corretamente seu docker-compose.yml e seu arquivo development 

  config.action_mailer.raise_delivery_errors = false
  
  config.action_mailer.default_url_options = { host: "http://localhost:3000" }
  
  config.action_mailer.delivery_method = :smtp
  config.action_mailer.smtp_settings = { address: "mailcatcher", port: 1025 }

Solução simples faça isso o que você está dizendo é gostaria de redirecionar requisição ao container "mailcatcher".

ActionMailer::Base.mail(to: 'jorge@gmail.com', from: "teste@test.com", subject: "Test sending", body: 
"Foiiiiiii").deliver_now!                                                                                => Como enviar o email

rails g mailer UserMails welcome                                                                         => Gerando uma estrutura de email.

> Erro de alteração de chave master

/usr/local/bundle/gems/activesupport-6.0.3.4/lib/active_support/message_encryptor.rb:206:in `rescue in _decrypt': ActiveSupport::MessageEncryptor::InvalidMessage (ActiveSupport::MessageEncryptor::InvalidMessage)

Solução deletar o file master e seu config/

> Rodar o console rails 

docker-compose run web bundle exec rails c

Job

Não passe o objeto direto para o job passe o seu id para ser chamado ok, seria dados desnecessários no redis.
Nunca faça várias ações em um background.

ExampleJob.perform_later
UserMailer.welcome_user(User.first.id).deliver_later(wait: 10.minutes)
UserMailer.welcome_user(User.first.id).deliver_later(wait_until: 5.days.from_now)

Sidekiq.redis { |conn| conn.flushdb}                                                          ** Com este comando você conseguirá apagar dados estatisticos do sidekiq.


Configurando idioma i18n

> Adicionando em config/application.rb

# I18n
config.i18n.load_path += Dir[Rails.root.join('config/locales/**/*.{rb,yml}')]
config.i18n.default_locale = :'pt-BR' 

> criar um diretório 

mkdir config/locales/pt-BR

> criar dois arquivo yml para configurar o activeRecord e o Devise

mkdir config/locales/pt-BR/{devise,active_record}.yml

links de onde obter os padrões em português:

  https://github.com/svenfuchs/rails-i18n/blob/master/rails/locale/pt-BR.yml
  https://gist.github.com/mateusg/924555

FATAL: Listen error: unable to monitor directories for changes.
sudo sh -c "echo fs.inotify.max_user_watches=524288 >> /etc/sysctl.conf"
sudo sysctl -p 
 
-------------------------------------------------------------------------------------------------------------------------------

API

gem "rack-cors"                              ** permite que outros sites nos chame 

Com configuração:
    config.middleware.insert_before 0, Rack::Cors do
        allow do
            origin: '*'
            resource: '*',
            headers: :any,
            methods: %i(get post patch delete options head)
        end
    end

gem 'rack-attack'                                                     => Protect your Rails and Rack apps from bad clients.
gem 'devise'                                                          => Criará 
gem 'simple_token_authentication'                                                          

gem install mailtcatcher                                              => gem para console, envio de emails

gem 'better_errors'                                                   => Se estiver usando a o rails RESTFULL cria uma tela amigável de error

gem 'figaro'                                                          => Gerencia as variáveis de ambiente
gem 'will-pagination'                                                 => 

gem 'simple_form'
gem 'haml'
gem 'kaminari'
gem 'kaminari-rails'                                                  => Solução para organizar e gerar paginação
gem 'ransack'                                                         => Trata de pesquisas/buscas
gem 'select2-rails'                                                   => Selects melhorados

gem 'pry'
gem 'pry-rails'
gem 'awesome_print'                                                   => console do rails c mais amigável
gem 'rspec-rails  '




sudo apt-get install apache2 curl git libmysqlclient-dev mysql-server nodejs                                  => instalação 1
curl -L https://get.rvm.io | bash -s stable                                                                   => key rvm
rvm requirements --autolibs=enable                                                                            => instalando prérequisitos rvm
rvm install 2.3.1                                                                                             => instalando uma versão ruby
rvm use 2.3.1                                                                                                 => dentre tantas versões apontar uma para usar
rvm list                                                                                                      => Lista todas as versões de ruby no rvm 
gem install rails --version=5.0.0.1 --no-ri --no-rdoc                                                         => instalando o rails uma versão específica
rvm --default 2.3.1                                                                                           => especificando uma versão ruby default
rails -v                                                                                                      => verficando verção rails 
gem list --local rails                                                                                        => Lista todas as versões rails presente
rails s ( bin/rails server)                                                                                   => acionar o server
rails s [server] [opições]                                                                                    => localhost//3000
rails s webrick
rails s -p 4000                                                                                               => Acessando porta 4000
rails s -e production                                                                                         => Definindo ambiente
rails s -d                                                                                                    => Servido de acesso Daemon
rails s -b 127.0.0.5                                                                                          => Sobe o servidor de densenvolvimento no ip 127.0.0.5
time rails runner ''                                                                                          => testar velocidade de carregamento rails


rails c                                                                                                       => Roda o console
reload!                                                                                                       => Você pode estar fazendo reload do seu console o/
Rails.application.credentials.google_secret_key                                                               => Conseguimos ter acesso a keys pelo nosso console rails.

<%= Rails.application.credentials.dig(:development, :password_db) %>                                          => Se quiser implementar em um database.

rails c [ambiente] [opições]                                                                                  => Ambiente = pode se production, development, ...
rails c --sandbox                                                                                             => Roda o console mais não altera o banco o final
rails db                                                                                                      => Acessa o console do banco de dados

rails about                                                                                                   => Mostra informações quantitativas da aplicação
rails stats                                                                                                   => Mostra mais informações quantitativas da app ( quantidade de models, controllers, etc...)
rails
RAILS_ENV=production rails production                                                                         => Pegando informações da app em produção

layout "Nome_do_template"                                                                                     => view/layouts podemos criar mais de um layout assim para referencia-lo, diferenciando do layout principal podemos escrever layout "nome_layout" no controller referente. 




EDITOR=vim rails credentials:edit                                                                            => editando as credentials.yml.enc ( Assim você edita um arquivo que será criptografado para editar a master key) 

rails credentials:show                                                                                        => Mostra o que há em credentials
rails new myproject --api --database=mysql -T
rails _6.0.3.3_ new myproject --api -d postgresql -T                                                         => Podemos estar passando uma versão rails específica
rails new <project> -d mysql                                                                                 => Cria uma nova aplicação e o -T representa sem a pasta Test
rake db:drop                                                                                                 => Deleta a sua base de dados inteira
rake db:create                                                                                               => Criar a base de dados 
rake db:rollback                                                                                             => Limpar a database criada pelo scaffold and return migration (drop)
rake db:migrate:reset                                                                                        => Irá fazer um drop, create e migrate
 
rails detroy scaffold <nome>                                                                                  => excluir scaffold

rails dev:cache                                                                                               => Note that this command will cause your server to automatically restart. "so  there’s  no  need  to  start from scratch on each request."

@product.order(:title)                                                                                        =>   
seed.rb > Product.delete_all                                                                                  => Com esta linha de código podemos deletar toda nossos dados para testa-los novamente. (Use o codigo a seguir para executar o comando)
bin/rails db:seeds                                                                                            => To populate your products table with test data, run the following command 

app/assets/stylesheets/scaffold.scss                                                                          => Podemos estar mudando o estilo de um view 

rails generate migration add_novaColuna_tabela                                                                => gera uma nova coluna, depois disso temos de ir ao migration e adicionar  add_column  :produto, :descricao, :text ( Veja na Documentação do ActiveRecord )
rails g migration AddColumnsToUser col1:integer col2:integer .. etc.                                          => gerar mais de uma coluna

bin/rails about                                                                                               => info app
bin/rails generate controller Say hello goodbye                                                               => é possivel gerar um controler criando ao mesmo tempos os métodos
bin/rails generate scaffold <Nome> 
       title:string description:text image_url:string price:decimal                                           => Cria a estrutura MVC de Product gerando um *migrate
bin/rails generate scaffold LineItem product:references cart:belongs_to                                       =>
belongs_to                                                                                                    => é um metodo foreign-key 
references                                                                                                    => é um método foreign-key ( também )
has_many :line_items, dependent: :destroy                                                                     => para certo model há "várias (0 ou n)" line_items qua dependem do model caso seja excluido todas os :line_items serão também na base de dados.
bin/rails generate scaffold add_quantity_to_line_items quantity:integer                                       => Adiciona uma coluna na tabela line_items
add_XXX_to_TABLE 
remove_XXX_from_TABLE         

Rake                                                                                                          => Server para fazer uma alteração na base de dados. Essa aula é muito boa #34
rake dbconsole ( rails c)                                                                                     => 
rake -T                                                                                                       => Lista de comandos 
rake routes 
rails g task apagar_dados <table>_produto1   <table>_produto2                                                 => Gera uma rake na lib > task para fazer uma execução no banco. Criando rakes  

rails console                                                                                                 => Console do rails onde posso estar fazendo buscas 
<%= render 'layout/menu' %>                                                                                   => Partials para a view desejada _menu.html.erb
@variable                                                                                                     => Variavel de contexto que pode ser acessada na view
<%= render 'layout/menu', projeto: 'Lana'  %>                                                                 => Passando uma parametro de uma view para a partial.

sudo lsof -wni tcp:3000                                                                                       => Verificar servidores ativos
sudo kill <PID>                                                                                               => Derrubar o servidor com o PID passado.
  kill -9 $(lsof -i tcp:3000 -t)                                                                                => Derrubar server
rake assets:clean && rake assets:precompile                                                                   => limpando cache


bin/rails db:migrate:status                                                                                    =>

bin/spring  stop                                                                                               => Para a execução do spring

before_destroy   :ensure_not_reference_by_any_line_item           (hook method)                               => É um validate como o metodo cascate no SQL, evita que uma produto seja deletado caso esteja presente em carts.
before_action                                                                                                 => UMa metodos auxiliares que são passados antes de se executar aguma action

index, show, create                                                                                           => São endpoints


bin/rails db:migrate 
rails db:migrate:redo STEP=3                                                                                  => Consegue desfazer os três últimos roolback
rails db:rollback                                                                                             => Desfaz o último migrate
rails db:rollback STEP=3                                                                                      => Desfaz os 3 últimos migrate 
bin/rails test                                                                                                => verifica erros na aplicação

<%= image_tag @usuario.avatar.thumb.url if @usuario.avatar? %>                                                => Implementação de imagem na view usando carrierwave

app/ models                                                                                                   => Nesta pasta serão tratada as validações
validates :title, :description, :image_url, :price, presence: true                                            => Validando existência 
validates :price, numericality: {greater_than_or_equal_to: 0.01}                                              => validação de valor numérico se for maior ou igual a 0.01
validates :title, uniqueness: true                                                                            => validação de uniciadade, verificando se o título inserido é o único.
validates :image_url, allow_blank: true, format {
  with:   %r{\.(jpg|png|gif)\Z}i,
  message:  'Inserir extensões JPG, GIF or PNG.' 
} 
bin/rails test test/controllers/line_items_controller_test.rb                                                 => test

bin                                                                                                           => Pasta onde encontra-se os executáveis / Aquivos de configuração / 
app                                                                                                           => Onde será escrita aplicação / Tudo que é dinâmico vai aqui
assets                                                                                                        => Agrupas os arquivos css e js para melhorar a performance do sistema. / nã mantem no cache
public                                                                                                        => Pasta estática que possui exemplo como Erros 500 e 404, com o apoio de cache do usuário, Status code
test/fixtures                                                                                                 => Consigo setar objetos para teste 
initializer                                                                                                   => A primeira pasta a ser executado quando chamo o servidor **
helpers                                                                                                       => Vai ajudar na construção do layout erb, agrupando pedaços de código. juntando um code de front e back ( uma boa comparação é com partials só que os helpers são melhores por que os partials não tem de haver tanta interação de back)

db                                                                                                            => Onde possue as configurações da base de dados
seed.rb                                                                                                       => Onde posso testa direto na base de dados

ApplicationHelpers                                                                                            => Serve para todos os contextos já que herda de ApplicationController

RAILS_ENV=production bundle exec rake assets:precompile                                                       => Subindo a aplicação para ambiente de produção compilando os assets ( Faz o mesmo que o Gulp - mais leve e performatico )

RAILS_ENV=production rails s                                                                                  => Executar em ambiente de produção

tails -f production.log                                                                                       => Acompanhando erros em produção, já que, não aparecerá no console automáticamente   

>GEMs

gem install backup -v5.0.0.beta.1                                                                             => Tivo problema para instalar essa gem, depende da versão ruby
gem devise                                                                                                    => Autenticação
gem 'devise_token_auth'                                                                                       => 'you want authentication, you need tokens, not cookies refreshes the tokens on each request, and expires them in a short time, so the app is secure'
  
gem 'omniAuth'                                                                                                => Um gem de autenticação via Facebook, google ... pode ser combinado com devise

gem 'cancancan'                                                                                               => Autorização 
gem 'pundit'                                                                                                  => mesma funcionalidade do cancancan contudo está sendo mais usada(2020)

gem 'carriewave'                                                                                              => upload de arquivos
gem 'paperclip'                                                                                               => upload de arquivos possui funcionalidade parecidas do Carriewave
gem 'shrine'                                                                                                  => upload de arquivos desenhada para ser assincrona
gem install mailcatcher                                                                                       => Envio de email pelo ambiente development. ( demora um pouco a instalação no sistema )
gem "bootstrap"                                                                                               => Configurações na pasta asset e javascrip > packs > application

bundle gem <nome da gem>                                                                                      => Criando uma gem
gem build <nome da gem>                                                                                       => Compilando a gem para ser executada

vendor/<nome_da_gem>                                                                                          => Podemos usar diretamento no projeto colocando a gem na pasta vendor (o rails irá compilar toda vez que subir o server);

Active Record 

<objeto>.all
<objeto>.save
<objeto>.find(id)
<objeto>.delete



Action Cable                                                                                                  =>  The client of a WebSocket connection is called the consumer.





* Iniciando novo_projeto

  
          ** sudo apt-get install curl
          ** https://get.rvm.io | bash -s stable --ruby
          ** Instalação do rvm   
          ** echo "source $HOME/.rvm/scripts/rvm" >> ~/.bash_profile
          ** source ~/.bashrc
          ** rvm                                          => Versionador ruby
          ** rvm install 2.0.0 ou rvm install 2.3.3 ...   => Assim vai um atalho para baixar várias versão de ruby;
         
          ** rvm use 2.0.0 ou rvm use 2.3.3 ...           => Apontar qual versão você deseja usar.
          ** gem install rails --no-ri --no-rdoc          => Caso não tenha o rails esse é o momento de instalar 
          ** gem list                                     => lista todas gems 
          **sudo apt install ruby-railties                => intalação do rails 
 

  1) init bundle
          **Some of the frameworks have builtin support for Bundler, e.g. when you run rails new app it will automatically init Bundler.
          https://bundler.io/v2.0/guides/using_bundler_in_applications.html#getting-started---installing-bundler-and-bundle-init
          bundle install é empregado quando queremos atualizar as gems.
          **sudo apt install ruby-bundler 
  1.1) Caso haja problema na instalação do gem mysql2:
          **sudo apt-get install libmysqlclient-dev
          **bundle install

  2) Um problema muito ruim é quando a versão ruby do system é diferente do rvm, quando há uma troca rvm use ruby-2.6.3 não é modificado no system:

         Problema de permissão:
         ** su - $USER                                     ** Dá ao usuário permissões de root em home do usuário
         ** rvm fix-permissions system                     ** Muda o estatos de permissão do rvm - /usr/share/rvm/rubies/
         ** id
         ** rvm install ruby-2.6.3                         ** Instala alguma versão do ruby
         ** rvm list                                       ** Lista todas as versões ruby presente
         ** rvm use 2.6.3                                  
         ** gem bundler install                            ** reinstação do bundler o gerenciador de gems
         ** bundle install
         ** gem 'thin'                                     ** Um servidor alternativo ao que vem no rails.Por padrão é o webpack
  3) rails new novo_projeto -d mysql                                                    ** Instalação do mysql
         ** sudo apt-get install mysql-server mysql-client libmysqlclient-dev           ** Fazer essa instalação do mysql2 antes 
         ** a mesma senha de root da sua máquina, root, será a mesma de todas os ambientes. Tome cuidado.

  4) Criando arquivos de controle de versão ( dentro da pasta de meu projeto)
          **.ruby-gemset                                  ** Nome da aplicação que será criada para se trabalhar com a versão no ruby-version
          **.ruby-vesion                                  ** Escreva a versão do rails que irá trabalhar no arquivo
  3) Criando banco 
          ** rake dbconsole                               ** Fazer consulta
          ** rails s                                      ** Carregar o servidor o mesmo que rails server
          ** rails s -e production                        ** Levanta o banco de dados de produção 

  3.1) Lembrar da gem install haml

  4) Criando pagina home e controller_home
          ** rails g Home index ( rails generation Home index)                           ** Criação de um controller home e uma action index 
          ** rails g controller home  
  4.1) Configuração da routes 
          ** get "home/index"
             root "home#index"

  4.2)
          ** rake -T                                                                     ** Exibe um help do gerenciador rake 
  4.3) Helpers
          ** localhost: 3000/rails/info/routes                                            ** Mostra todas as rotas

  5) Criando um modelo
          ** rails g model user
          ** rails generate scaffold custumer  nome:string email:string obs:string       ** Por convenção do rails os modelos são no singular mas as tabelas serão no plural
          ** timestamps(created_at e updated_at)                                                            ** Por convenção o rails cria para você um id e chave primária
          ** rake db:migrate
  6) Caso necessite desfazer do modelo 
          ** rails d model user
  7) Fiz uma migração errada 
          ** rails db:rollback           
!>8) Criando um cadastro de post
          ** rails g scaffold Post titulo:string descricao:text
  9) Deleta o banco , cria um banco e faz a migração
     rake db:drop db:create db:migrate
-------------------------------------------------

Testes automatizados - Rspec

gem install rspect
rspect --init                                                    ++ Inicializa o gem rspec sem o Gemfile

gem 'rspec-rails'                                                ++ Em um projeto rails no Gemfile
rails genarate rspec:install                                     ++ Gera as pastas necessárias e helper do rspec
rails genarate rspec:request User                                ++ Cria um teste request para o model user
rails generate --help | grep rspec                               ++ Lista de generate do rails 
rails generate rspec:model <nome>                                ++ gera a estrutura spec para model <nome>

describe                                                         ++ Definir Grupos de testes pode receber uma classe ou string '#index'
context                                                          ++ Agrupar testes associados, é subcategoria para agrupar os testes parecidos
it                                                               ++ Defini um exemplo ( teste )
expect                                                           ++ Verifica condições

match                                                            ++ verificar se uma condição está sendo atendida
expect(actual).to eq(expected)
expect(actual).to eql(y)
expect(actual).to be(y)

# Match de comparação 

expect(atual).to be > x           
expect(atual).to be >= x
expect(atual).to be <= x
expect(atual).to be < x

expect(atual).to match(/expression/)                             

# Match de tipos, verificar tipo

expect(actual).to be_an_instance_of(expected)
expect(actual).to be_a(expected)

expect(actual).to be_truthy
expect(actual).to be true
expect(atual).to be_falsy
expect(atual).to be false
expect(atual).to be_nil
expect(atual).to_not be_nill

expect {...}.to raise_error
expect {...}.to raise-error(ErrorClass)
expect {...}.to raise-error("message")
expect {...}.to raise-error(ErrorClass, "message")

Em um projeto Rails tanto para ser usado a gem faker quanto o shoulda-matchers devemos
criar a pasta support

> touch spec/support/{factory,shoulda_matchers}.rb 

  RSpec.configure do |config|
    config.include FactoryBot::Syntax::Methods
  end

gem FFAKER                                                      ++ Permite gerar valores aleatórios - Evita dados viciados 
FFaker::Name.name                                               ++ Gera um nome 
FFaker::Internet.email                                          ++ gera email fake
FFaker::Andress.city                                            ++ cidade fake
    nickname = FFaker::Name.first_name
    kind = %i[knight wizard].sample
    level = FFaker::Random.rand(10..99)  

gem factory_bot_rails                                           ++ Parecido com o Fixtures do test Há um processo de criação de diretórios

config.include FactoryBot::Syntax::Methods                      ++ incluir dentro do arquivo rails_helper

testes de request                                               ++ integração de model, controller, server um teste mais global

# Controllers devem ser adaptadores. Não devem possuir regras de negócio, apenas regras de fluxo e exibição.

rails g controller users index create --no-helper --no-assets --no-controller-specs --no-view-specs --skip-routes
rails g controller enemies update destroy --no-helper --no-assets --no-controller-specs --no-view-specs --skip-routes

rails destroy controller users                                  ++ Desfaz todo generate realizado de user.  

rails g --help                                                  ++ mostrará uma lista com todos os generates

expect(response).to have_http_status(200)                       ++ 200 é um statu de sucesso

bundle exec rspec spec/validators/future_date_validator_spec.rb:13  ++ Podemos rodar o teste de um validator específico desta forma apontando a exata linha.

Shoulda-matchers

it{ is_expected.to validate_presence_of(:<nome_atributo>) }
it{ is_expected.to validate_uniqueness_of(:name).ignoring_case_sensitivity }
it{ is_expected.to define_enum_for(:mode).with_values({pvp: 1, pve: 2, both: 3}) }
it{ is_expected.to define_enum_for(:status).with_values( {active: 1, inactive: 2})}
it{ is_expected.to validates_numericality_of(:discount_value).is_greater_than(0) }
it{ is_expected.to validates_numericality_of(:discount_value).is_greater_than_or_equal_to(0) }
it{ expect( subject).to validate_presence_of( :<nome_atributo> ) }
it{ is_expected.to belong_to <model>}
it{ is_expected.to have_many(:games).dependent(:restrict_with_error) }
it { is_expected.to have_one <model> }

Criando um alias para métodos no rspec > rails_helper.rb

RSpec.configure do |config|
  config.fixture_path = "#{::Rails.root}/spec/fixtures"
  config.use_transactional_fixtures = true
  config.infer_spec_type_from_file_location!
  config.filter_rails_from_backtrace!
  config.alias_it_behaves_like_to :it_has_behavior_of, 'has behavior of' # Nesse ponto podemos estar modificando a descrição
end

Flags para poder ver as descrições do rspec 

rspec spec/models/license_spec.rb -f d


> Error ao executar algumas classes do Faker

I18n::MissingTranslationData (translation missing: en.faker.commerce.department)

solução: 

Modifique seu application possibilitando mais de um locale:

config.i18n.available_locales = %i[pt-BR en]

.and_wrap_original                                                ++ Manipular expects de suit de testes com verificação multipla



---------------------------------- Usando Minitest --------------------------------------------------------------

def setup
end

def teardown
endk



-------------------------------------------------------------------------------------------------------

get                                                             ++ Adquirir dados do banco
pos                                                             ++ inserir dados

Testes de View - end-to-end - teste de aceitação ou integração 

Capybara 
Selenium é um webdriver é como se fosse um navegador web.
Por default o rails usa o Raketest    

Editar o rails_helper:

require 'capybara/rspec'

Capybara.register_driver :selenium_chrome do |app|
  Capybara::Selenium::Driver.new(app, browser: :chrome)
end

:selenium_chrome é diferente do chrome que nós usamos como navegador de sistema

https://makandracards.com/makandra/29465-install-chromedriver-on-linux        ++ Devemos instalar um navegar especial por meio desse link

gem 'launchy'                                                                 ++ usando-se save_and_open_page podemos abrir uma janela de navegador e testar no cenário







--------------------------------------------------

Scaffold 
   rails generate scaffold cliente nome idade: integer --migration= false -s
   # Bastante interessante: cliente recebe todas as views e controller criados anteriormente na migration 
 
________________________________________________________

Partials 
   São pedaços de html.erb que podem ser visualizados em outras views.
   Agora, para ser criado um partial basta criar um arquivo _meupartial na view desejada 
   logo depois podemos incrementa-lo onde é necessário com render partial: "meupartial".
   Lembre-se do underscore.  -Reaproveitamento de código erb.

ApplicationHelper - 

________________________________________________________

debugger rails 

  GemFile

  group :development, :test do
    gem 'pry-byebug'
  end

  <% require 'pry'; binding.pry %>  # no html.erb
   - binding.pry # no haml
   binding.pry  # no ruby


Combine 'pry' with 'byebug'. Adds 'step', 'next', 'finish', 'continue' and 'break' commands to control execution.


** Como usar o debug
   insira o codigo flag onde se deseja fazer a pausa, você conseguirar visualizar no inspetor do navegador. Conseguentimento no seu terminal aparecerá um console main pry >, para consulta 

  whereami # retornará sua posição.
  exit-program # saida bruta


________________________________________________________

Record Rails :: Base
belongs_to, has_one, has_many, has_and_belongs_to_many_ = https://www.devmedia.com.br/introducao-a-relacionamentos-no-ruby-on-rails/33860

https://guides.rubyonrails.org/active_record_basics.html

________________________________________________________

Docs 

gem server                                             * Comando que inicia o servidor WebRick na porta 8808

________________________________________________________

Action Jobs

*https://onebitcode.com/dominando-o-uso-de-jobs-no-rails/

--------------------------- >React -------------------------------------------------------

npx create-react-app                                 ** Criar uma estrutura react SPA. Tendo um server hot reload

class <name> extends React.Components{                ** Component de classes - States ( Uma forma mais antiga)
    constructor(props){  
      super(props);
      this.states = {
        name: "dados"
      }
    }

    render(){
    
    }
}     

{/*     */}                                         ** Adicinar comentários no React.
ReactDOM.render(componentToRender, targetNode)      ** Renderizar react no html.
ReactDOM.render(<TypesOfFood />, document.getElementById('challenge-node'));

{props.tasks.join(', ')}
<List tasks={["react","bootstap","sass"]} />

MyComponent.defaultProps = { location: 'San Francisco' }

MyComponent.propTypes = { handleClick: PropTypes.func.isRequired }                   ** Definindo o tipo da propriedade passada

this.props.name                                                                      ** this é empregado em passagem de propriedades em classes

 this.handleClick = this.handleClick.bind(this);                                     ** uma função empregada em class components tem de ser atribuito ao bind para serem empregadas

--------------------------------------------------------
class MyComponent extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      text: "Hello"
    };
    // change code below this line
    this.handleClick = this.handleClick.bind(this);
    // change code above this line
  }
  handleClick() {
    this.setState({
      text: "You clicked!"
    });
  }
  render() {
    return (
      <div>
        { /* change code below this line */ }
        <button onClick={this.handleClick}>Click Me</button>
        { /* change code above this line */ }
        <h1>{this.state.text}</h1>
      </div>
    );
  }
};
----------------------------------------------------------
                                                                                      ** Como trabalhar update de atributos assincronos.
this.setState((state, props) => ({
  counter: state.counter + props.increment
}));
                                                                                      ** Lifecycle react
componentWillMount() 
componentDidMount() 
shouldComponentUpdate() 
componentDidUpdate() 
componentWillUnmount()

<div style={{color: "red", fontSize:"72px"}}>Big Red</div>                            ** Inserindo estilo inline

----------------------------------------------------------
                                                                                      ** Podemos criar uma condição inline no render 
  render() {
    // change code below this line
    
    return (
       <div>
         <button onClick={this.toggleDisplay}>Toggle Display</button>
         {this.state.display && <h1>Displayed</h1>}
       </div>
    );

------------------------------------------------------------

class App extends React.Component {                                                   ** Podemos executar um server no react 
  constructor(props) {
    super(props);
  }
  render() {
    return <div/>
  }
};

// change code below this line

ReactDOMServer.renderToString(<App />);

-------------------------------------------------------------

this.setState()                                     ** Forma de setar um estado

npm i react-router-dom   --save                     ** Criação de rotas.
npm i axios --save                                  ** Igual ao fetch, serve para chamar end-points externos.  
npm i node-sass --save                              ** sass
npm i bulma --save
npm i rbx --save                                    ** um lib bulma
npm i moment --save-dev

npm i @fortawesome/fontawesome-svg-core --save
npm i @fortawesome/free-solid-svg-icons --save
npm i @fortawesome/react-fontawesome --save

mkdir src/assets
mkdir src/assets/images
mkdir src/components
mkdir src/screens
mkdir src/styles

mv src/App.css src/App.scss

$custom-purple: #694ED8 !default;
$custom-purple-darker: #6600CC !default;

--- API ----------------------------------------- 

npm i express-generator
express --view=no-view <nome-do-projeto-api> 
npm install 
npm install express-generator -g
npm install nodemon --save
npm install mongoose --save

npm install bcrypt --save
npm install jsonwebtoken --save
npm install dotenv --save
npm install cors --save                    (Permitindo que possamos chamar recursos de outros sites)
npm install react-burger-menu --save
npm install react-quill --save              Editor de textos

npm i -S @react-google-maps/api


---------------------------> React Native ------------------------------------------------

Criando um app com a ferramenta expo

npm install --global expo-cli                        ** Instalação de dependencias

npx create-react-native-app <nome_do_projetO>
expo start --turnnel


sudo ufw status verbose                              ** Verificar endereços permitidos tcp
sudo ufw allow 19000/tcp                             ** Essas duas portas tem de ser habilitadas 
sudo ufw allow 19001/tcp

expo install react-native-maps                       ** instalando pacote de mapas

ngrok                                                ** ngrok é uma aplicação que nos possibilita tornar nossa api disponível ao app por meio de um endpoint
ngrok http 3001

Rails.application.configure do                       ** temos de acrescentar este trecho para habilitar o acesso de outros hosts a essa porta.
  config.hosts.clear
end

--------------------------- > Redis ------------------------------------------------------

redis-server                                         ** Subir o servidor
redis-cli                                            ** Abrir o console do redis
redis-server --daemonize yes                         ** Rodar o redis background

ps aux | grep redis-server                           ** Verificar se redis está sendo executado

alias redis-server='redis-server --daemonize yes' to your ~/.bash_profile t                    ** Podemos fazer um alias também 

crie um arquivo chamado config/redis.yml

```
  default: &default
    host: 127.0.0.1
    port: 6379

  development:
    <<: *default

  test:
    <<: *default
    db: 1 
``` 

crie um arquivo chamado config/initializers/redis.rb

```
  if Rails.env.production?
    $redis = Redis.new(url: ENV['REDIS_URL']) 
  else
    redis_config = YAML.load(File.open(Rails.root.join('config/redis.yml'))).symbolize_keys[Rails.env.to_sym]
    $redis = Redis.new(redis_config)
  end
```

background jobs
--------------------------- > Redux ------------------------------------------------------

let store = Redux.createStore(reducer);              ** Define um store 

let currentState = store.getState();                 ** Podemos recuperar o valor usando o get

store.dispatch(actionCreator());                     ** criamos ações e states, mas para guarda-los precisamos dar um dispatch.
store.dispatch({ type: 'LOGIN' });



------------------------- > Rubocop ------------------------------------------------------


gem 'rubocop', require: false                        ** instalar o rubocop no projeto

rubocop                                              ** Fazer analise de todo o projeto 

--------------------------- >Ruby --------------------------------------------------------

Tell don't ask

sudo apt  install ruby-railties                      ** instalation gem rails utilitaries 
aptitude purge ruby                                  ** desinstalar ruby

1.upto(7) do |numero|                                ** Esse método realiza uma iteração continua de 1 até 7 parece um range 
  puts numero
end


[1,2,3,4,5].inject(:+)                               ** Forma de soma reduzida do inject 
[1,2,3,4,5].inject(:*)                               ** Forma de multiplicação reduzida do inject
[1,2,3,4,5].inject(:-)                               ** Forma de subtração reduzida do inject 

[1,2,3,4,5,6,7];select { |valor| valor % 2 == 0 }    ** O select realiza uma filtragem em nosso array.

p Livro.superclass.methods # => [..., :inspect, ...] ** Podemos também listar os métodos da superclass

p teste_e_design.eql? web_design_responsivo # => true ** Usando o eql?

%Q{ Titulo: #{ @titulo } }                           ** Assim consigo fazer a criação de uma string com interpolação 

numero_sem_repeticao = Set.new [1, 2, 2, 3, 2, 1]    ** Não usando números repetidos para acessa-lo devemos usar estruturas de controler

-------------------------------------------------------------------------------------------

Quando invocamos o initialize da superclasse apenas com super sem os
parenteses, o interpretador Ruby tentará invocá-lo passando os mesmos parâmetros
recebidos pelo método initialize da subclasse.

--------------------------------------------------------------------------------------------
"Algumas classes ancestrais ou superclasses fornecem métodos que são projeta-
dos para serem substituídos pelas classes descendentes ou subclasses. Este compor-
tamento quando bem definido e explicado pode ser muito útil, já que na superclasse
podemos definir a maior parte dos comportamentos deixando apenas alguma parte
do comportamento para ser customizado pelas subclasses. Este tipo de comporta-
mento é tão comum que virou um Design Pattern chamado Template Method." Livro Caelum ( Ruby )

--------------------------------------------------------------------------------------------


Thread Safe.                                         ** Quandio temos código sendo executado paralelamente

Parte de Paradigma funcional / funções puras    ----------------------------------------

nome = "Lucas"
puts nome.upcase # => LUCAS
puts nome # => Lucas

puts nome.updase! # => Nesse caso haverá mudança definitiva para LUCAS usando o bang não sendo um método funcional


valor = nil
numero = "dois"
if numero == "um" then valor = 1
elsif numero == "dois" then valor = 2
else valor = 3
end
p valor # => 2

ou 

numero = "dois"
valor = if numero == "um" then 1
          elsif numero == "dois" then 2
          else 3
        end
p valor # => 2

a = b = c = 0
p a, b, c # => 0 0 0

numeros = [1, 2, 3, 4]
novos_numeros = for n in numeros
n * 2
end
p novos_numeros # => [1, 2, 3, 4]


---------------------------------------------------------------------

Módulos 

  Módulos não podem ser instanciados a suas únicas funções são de servir
de namespace e podermos compartilhar código.

"O que fazemos é um include do módulo criado em uma ou várias classes, e assim as 
classes que incluíram aquele módulo passam a ter em sua interface todos os métodos 
de instância definidos no módulo incluído. Nós misturamos os métodos na classe que 
incluiu o módulo, daí vem o nome mixings."

"Se você precisa incluir comportamentos existentes em um módulo apenas em
alguns objetos, pode fazer isso utilizando a palavra chave extend ao invés de
include ."


Metodo clone - Herança por compartamento

clone faz herança do estado atual a uma variável

a = "Um String qualquer" # temos uma instância de uma String

def a.testando 
  puts "Estamos adicionando um comportamento a a"
end

b = a.clone       # estamos clonando os comportamentos e estado de dada instância "a" à instância "b".

class << a - Podemos estar passando múltiplos métodos à uma instância 

class << a

  def primeiro_comportamento
    puts "primeiro comportamento"
  end

  def segundo_comportamento
    puts "segundo comportamento"
  end
end

dup - Podemos também copiar apenas o estado

c = a.dup

c # será igual a "Um String qualquer" e não terá os comportamentos de a

Include e Extend

Include é usado para estender instâncias

Modulo Teste 
  def teste 
    puts "Metodo de instância."
  end
end

a = "Uma String" # a é uma instância de String

a.include Teste

a.teste      # podemos usar o método teste como o Namespace

Extend já é usado para estender classes 

String.extend Teste   # Estamos estendendo o modulo Teste na class String, agora teste é um método de instância

Exemplo com os dois modos - Herança por comportamento

module InstanciaEClasse
  def instancia
    "metodo de instancia"
  end

  module Classe
    def de_classe
      "metodo de classe"
    end
  end
end

class Teste
  include InstanciaEClasse
  extend InstanciaEClass::Class
end

Teste.new.instancia
Teste.de_classe

Podemos estar fazendo com um comando só

module InstanciaEClasse
  def instancia
    "metodo de instancia"
  end

  def instancia
    "metodo de instancia"
  end

  def self.included(cls)    # usando o included estendendo os métodos de class cls é class atual é errado usar o self herança por comportamento
    cls.extend Class
  end

  module Classe
    def de_classe
      "metodo de classe"
    end
  end
end

class Teste
  include InstanciaEClasse
end

Teste.new.instancia
Teste.de_classe

defined_method                # Criando métodos dinâmicos ao invés de se usar o eval, criando em runtime

class Teste
  def self.definir(valor)
    define_method(valor) do |param1, param2|
      puts "#{param1} - #{param2}"
    end
  end
end 

Teste.definir("novo_metodo")

attr_accessor                 # Como é por dentro 

module AtributosDinamicos
  def atributos(*args)
    atrs.each do |atr|
      
      define_method("#{atr}=") do |value|
        instance_variable_set "@#{atr}", value
      end

      define_method("#{atr}") do |value|
        instance_variable_get "@#{atr}"
      end

    end
  end

  def atributos_somente_leitura(*args)
    atrs.each do |atr|
      define_method("#{atr}") do |value|
        instance_variable_get "@#{atr}"
      end
    end
  end
end 

class Teste
  extend AtributosDinamicos
  atributos :nome, :telefone
  # attr_accessor :nome, :telefone ( possui a mesma função )
end


instance_eval e class_eval 

Possibilita abrir a classe e estar "capturando" valores mesmo que sejam privados

class Teste
  @telefone = "555"
  def initialize
    @nome="AlgumNome"
  end
end

Teste.new.instance_eval { @nome }  # consigo estar fazendo get em nome que é uma variável privada da classe Teste

Possibita também definirmos métodos em runtime, abrindo o bloco da instância

teste = Teste.new

teste.instance_eval do
  def metodo1
    puts "method1"
  end
  def metodo1
    puts "method1"
  end
end

puts teste.metodo1

Mas a diferença de se usar class_eval e instace_eval para uma classe exemplo

Teste.instance_eval do
  def metodo1
    puts "method1"
  end
  def metodo1
    puts "method1"
  end
end

Teste.metodo1        # Veja, estamos criando método de classe

Teste.class_eval do
  def metodo_de_instancia
    puts "method1"
  end
  def metodo1
    puts "method1"
  end
end

Teste.new.metodo_de_instancia   # Veja, estamos criando método de instância. 

Monkey Patching / dynamic runtime patching  - Um exemplo seria usar o class_eval para alterar uma gem que não está atendendo em um determinado ponto => https://pt.stackoverflow.com/questions/285190/o-que-%C3%A9-monkey-patch

Podemos modificar Constante de sistema para atender nossas necessidades, Como assim Botine? Vamos ter como exemplo 
a classe de sistema String.

String.class_eval do
  def metodo_de_instancia
    puts "Definindo um novo comportamento à instância de classe String"
  end
end

"testando".metodo_de_instancia

String.instance_eval # ou class << String
  def metodo_de_class
    puts "Esse é um método de classe."
  end
end

String.metodo_de_class



alias_method 

send(<recebe_uma_string_com_um_metodo_da_instancia>) ou send(<recebe_uma_string_com_um_metodo_da_instancia>, &bloco)

Tipos de Hook - quando se realiza uma ação é executada outra ação

APP Hooks
Web Hook ( Exemplo Gateway de pagamento )
SQL Jobs ( Trigger )

Assista = https://www.youtube.com/watch?v=uOOWUqwDgLE&list=PLEdPHGYbHhldWUFs2Q-jSzXAv3NXh4wu0&index=19&ab_channel=DaniloAparecido-Torne-seumprogramador

included
extended
inherited

Missings

def const_missing()
end

const_set(nome_da_classe, Class.new)

--------------------------------------------------------------------

Como definir classes dinâmicamente em runtime

criando_uma_classe = "teste"
criando_uma_classe.capitalize! # necessário capitalizar a primeira letra pois classes possuem a primeira letra em maiusculo
eval("class #{ criando_uma_classe } end") # fazendo a criação
criando_uma_classe = Object.const_get(criando_uma_classe) # retorna o objeto

puts criando_uma_classe # retornará uma classe 

Como definir classes e métodos dinâmicamente 

https://www.youtube.com/watch?v=03nk3PVoIJA&list=PLEdPHGYbHhldWUFs2Q-jSzXAv3NXh4wu0&index=17&ab_channel=DaniloAparecido-Torne-seumprogramador



---------------------------------------------------------------------

Duck Typing: o polimorfismo aplicado no Ruby

Duck Typing considera o que um objeto pode fazer e não de qual tipo ele é, que-
brando a ligação com a classe do objeto criado.

"A ideia do duck typing é que um tipo em Ruby não é definido por uma classe ou interface mas pelo uso que se faz dos objetos."

if midia.kind_of? Midia

O método kind_of? verifica se dado objeto é de um tipo


Outro método seria o respond_to? que faz a verificação por método

def midias_por_categoria(categoria)
  midias.select do |midia|
    midia.categoria == categoria if midia.respond_to? :categoria
  end
end 

Funções de high-order ----------------------------------------------

Basicamente são funções capazes de receber outras funções é o caso de
lambdas, procs e bloco

Blocos

each

numeros = [1, 2, 3, 4]
numeros.each { |numero| p numero }

collect

numeros = [1, 2, 3, 4]
numeros_ao_quadrado = numeros.collect { |numero| numero ** 2 }
p numeros_ao_quadrado # => [1, 4, 9, 16]


Usando o método block_given? caso nenhuma bloco seja passa como parâmetro evitando lançamento 
de erro.

def livros_por_categoria(categoria)
  @livros[categoria].each do |livro|
    yield livro if block_given?
  end
end

------------------------------- Explorando API Ruby Enumerable ---------------------------

Enumerable são esses métodos que permitem iteração de coleções

Inject é bem parecido com o reduce do JS 

def soma_total
  @produtos.inject(0) { |total, produto| total += produto.value }
end

Em poucas linhas estamos fazendo uma soma.


-------------------------------- Usando o Map ----------------------------------------------

def titulos
  @biblioteca.livros.map { |livro| livro.titulo }
end

podemos melhorar o map dessa forma

def titulos 
  @biblioteca.livros.map &:titulo 
end



gem install bundler                                  ** controlodor de versoes de gems 
irb                                                  ** interpretador ruby
pry                                                  ** É um interpretador irb bombado como é uma gem tem de ser instalado com syntaxe "raylight"

puts, p e  print                                     ** Imprimindo algo em ruby
puts                                                 ** Imprimir no console e pula linha
p                                                    ** Utilizado como metodo inspect
print                                                ** imprime no console mas vai imprimir um do lado do outro 

# / =begin bloco =end                                ** Comentarios em ruby Pode haver comentarios de linha simples ou bloco (multiplas linhas)

Metodo .class                                        ** Metodo para obter o tipo da variavel.

classe, instancias , contrutores 

meta_programer   attr_accessor, attr_writer, attr_reader                                               ** 

7_000_000_                                           ** Podemos separar numeros grandes com underscore  

{:key => "value", :key => "value"}.values            ** Retorna todos os values

{:key => "value", :key => [ [ "values" ] ]}.values.flatten              ** O método flatten é recurciso mesmo tendo array dentro de array o retorno será um único array contendo os valores da hash.


require_relative                                     ** Acessando classes para meu codigo.rb 

runtime - criar methodos durante execução            ** a.methods irá mostrar todos os metodos de uma determinada classe ( String, float, ou uma criada por você ...)

a = objetos

a = lambda do /p/                                    ** O lambda posso passar ou não um parâmetro para uma variável para excutar um bloco contudo apenas um parametro se for colocado /p1, p2, p3 /
  puts p                                           ** Sou obrigado a char no call 3 argumentos. Só aceita os parâmetros definidos.
end
a.call ("Jorge")

a = proc.new do /p,p1,p2/                            ** Com o proc você poderá fazer *args adicionar mais parametros na chamada podem ou não executar todos
  puts p , p1

end

a.call( "jorge", "cozinha")


def methodo ( &bloco)                                ** Permite que eu passe um blco em um méthodo, usando um PROC.new é como se fosse um callback do js 
  bloco
end.call    #nao entendi o call no final

eval("puts '1,2,3'")                                 ** Executa veja nem usei o #{} no comando  

jorge = Object.const_get(jorge)                      ** Criando uma classe dinamicamente retornando um objeto

String.downcase                                      ** tudo fica minusculo
String.upcase                                        ** tudo maiusculo

Herança
Polimorfismo
super

alias_method                                         ** Usar método renomeando o original - uma herança ~ Polimorfismo não perdendo o método original ( cria uma cópia )
define_method                                        ** 
modele
send                                                 ** o send( 'metodo' )  ele tenta achar algum método na instancia tonando dinamico dentro de outro método ; Uma observação o método tem de estar como string      

hooks                                                **  Gancho 
  included                                           ** Modulos aponta para a instancia ( Reação - Despara um hook)
  extended                                           ** Modulo aponta para classe ( Reação - Despara um hook )
  inherited                                          ** Classe ( Reação - despara um hook  )
  callback
  fallback 
  gate de pagamento
  tiggers                                              ** nos bancos de dados seriam atualizações, alterações, drops, .../ Meio que dispara um gatilho para alguma coisa
  jobs                                                 ** executar uma ação em background ou runtime

Module                                               ** Classe superior que pode ser overwrite para modificar hooks como os missing
missing                                              ** Um elemento do ActivenRecord muito importante const_missing                                                      ** Mostrar que alguma classe ou constante não existe 
method_missing                                       ** Vamos fazer um overwrite, indica que algum método ou atributo exista possivel para um metodo de instancia também Class1.new

<string>.casecmp? <segunda string>                   ** Podemos comparar uma palavra com outra sem case sensitive;




  
Strings em Ruby são mutaveis
O operador << faz a concatenacao de strings na mesma instancia. 
Ja o operador + faz concatenacao gerando uma nova string.

#{}                                                  ** Interpolação

Metodo Capitalize - e uma funcao pura que torna a primeira letra da
palavra maiuscula. Nao ha modificacao direta da variavel.

Metodo terminado em bang(!) - torna definitivo, como assim .
nome = "jorge"
puts nome.capitalize! # Jorge
puts nome # Ainda será Jorge

Symbols são strings só que imutáveis, representado por :palavra.

Condicional if elsif.
Estrutura de repetição for i in (1..9) end. 
switch  =>  case variavel when ... when ... when ... end

https://www.sergiotoledo.com.br/tutoriais/ruby/strings-com-ruby

Expressões regulares são limitada por /rio/ =~ "São paulo" ( por barras). O =~ tem a funcao de match.
*Rubular.com é um site no qual você pode estar encontrando expressoes regulares.

Operador ||= , caso a variável esteja vazia ou seja nil preencha com o valor para atribuido.

Conversão de tipo de string para inteiro string.to_i para o float string.to_f.
Converter de range para array (1..6).to_a.  

Ruby é uma linguagem considerada puramente orientada a objeto. Tudo em ruby é objeto até os tipos basico.

O metodo .object_id retorna o numero ( identificador unico na memoria heap) do objeto enquanto o .class() retorna o tipo do objeto.

Criando um objeto com novo = Object.new

Uma declaracao de metodo basta introduzir o 'def' no inicio uma particularidade de ruby e que nao precisamos forcar uma
impressao a ultima linha do metodo e impresso automaticamente, isso para evitar os ruido sintatico.
Podendo se passar argumentos e parametros.

Agora foi realizado a criacao de uma class e uma instanciacao de variavel.
Dentro da class sao acrescentados metodos.
A class e mutavel a qualquer podemos adicionar novos metodos a ela.

Bibliotecas padrao Object e Fixnum - Qualquer classe em ruby pode ser reaberta e redefinida.

Modificadores de acesso = "Atributos em ruby são sempre privados não podemos modifica-los fora da classe, também são
chamados de variáveis de instância". Encapsulamento @nome ( variavel )

initialize ao um objeto ser criado nos iniciailizamos automaticamentes seus atributos por meio desse metodo. Sendo um
metodo privado nao pode ser chamado fora da classe.

Syntax Suger do Ruby e uma forma de facilitar legibilidade do codigo.

definindo propriedade de acesso attr_accessor , attr_reader, attr_writer / tem de ser passado um simbolo :nome

Para receber um número qualquer de parametros usamos a sintaxe *(asteristico) - sendo assim def metodo(*param)
essa variavel param funciona como um array. Esse operador * é chamado de splat

Hash é uma estrutura indexada por qualquer tipo de objeto, confg = Hash.new     confg["nome"] = "Jorge"
temos tambem uma sintaxe mais explicita {:nome = "jorge", :sobreNome ="Borges"} ou uma sintaxe mais antiga temos {:nome => "Jorge", :sobrenome => "Borges"}

Mas assim como uso do parenteses e opcional no Syntax Sugar, podemos ter a exclusao das chaves na Hash :nome = "Jorge", :sobrenome = "Borges".



------------------------- >Sass ------------------------------------------

$main-fonts: Arial, sans-serif;                           => Variáveis

                                                          => Aninhando   
nav {
  background-color: red;

  ul {
    list-style: none;

    li {
      display: inline-block;
    }
  }
}
                                                          => Usando o mixin para comprimir estilos em um único seletor;
<style type='text/scss'>
  @mixin border-radius($radius){
    -webkit-border-radius: $radius;
    -moz-border-radius: $radius; 
    -ms-border-radius: $radius;
    border-radius: $radius;
  }

  #awesome {
    width: 150px;
    height: 150px;
    background-color: green;
    @include border-radius(15px);

  }
</style>

<div id="awesome"></div>



                                                          => Condições em SASS 
<style type='text/scss'>
 
  @mixin border-stroke($val){
    @if $val == light {
      border: 1px solid black;
    }
    @else if $val == medium {
      border: 3px solid black;
    }
    @else if $val == heavy {
      border: 6px solid black;
    }
    @else{
      border: none;
    }
  }


  #box {
    width: 150px;
    height: 150px;
    background-color: red;
    @include border-stroke(medium);
  }
</style>

<div id="box"></div>


                                                          => loop usando o to que "excludes the end number as part of the count";

<style type='text/scss'>                                  => Também temos o through que "includes the end number as part of the count";
  
@for $j from 1 to 6 {
    .text-#{$j}{
      font-size:15px*$j;
    }
}

</style>

<p class="text-1">Hello</p>
<p class="text-2">Hello</p>
<p class="text-3">Hello</p>
<p class="text-4">Hello</p>
<p class="text-5">Hello</p>


                                                          => Usando map para iterar dados.

<style type='text/scss'>
  $colors: (blue, black, red);

  @each $color in $colors{
    .#{$color}-bg{
      background-color: $color;
    }
  }


  div {
    height: 200px;
    width: 200px;
  }
</style>

<div class="blue-bg"></div>
<div class="black-bg"></div>
<div class="red-bg"></div>


$colors: (color1: blue, color2: red, color3: green);       => Outra possibilidade usando chave e valor.

@each $key, $color in $colors {
  .#{$color}-text {color: $color;}
}



$x: 1;                                                     => Usando o while no sass
@while $x < 13 {
  .col-#{$x} { width: 100%/12 * $x;}
  $x: $x + 1;
}

                                                          => Podemos extender e importar código
<style type='text/scss'>
  h3{
    text-align: center;
  }
  .info{
    width: 200px;
    border: 1px solid black;
    margin: 0 auto;
  }
  
  .info-important{
    @extend .info;
    background-color: magenta;
  }



</style>

-------------------------- >Sidekiq ---------------------------------------

Configurar o sidekiq

https://github.com/mperham/sidekiq/wiki/Advanced-Options

sidekiq -C config/sidekiq.yml 

Crie um arquivo chamado config/sidekiq.yml

```
---
  :concurrency: 5
  staging:
    :concurrency: 10
  production:
    :concurrency: 20
  :queues:
    - critical
    - default
    - low
    - mailers
 ```



------------------------- >Sublime_text dicas------------------------------
Plugins
 - Emmet
 - Alignment
 - Terminal
 - PlainTask
 - AdvancedNewFile 
 - LoremIpsum
 - A file icon 
 - View in Browser
 - ColorHighlight
 - Copy Relative Path

Copia o caminho relativo - Super + i                                   ** ( Copia o caminho relativo do arquivo )
Goto anything - Control + p                                            ** ( Faz uma busca de arquivos)
Command Palette - Control + shift + p                                  ** ( Faz uma busca por atalho )
Multiple Selection - Shift + alt + P                                   ** ( Multipla seleção )
Pesquisa de palavra marcada - Control + D                              ** ( selecione uma palavra e será feita as marcações )
Distract free mode - Shift + F11                                       ** ( Modo sem distração)
Modificando layout de tela - alt + shift + 2 < 3 4 5                   ** ( Podemos deixar com uma coluna uma, duas,três ou quatro)

Control + pgup/pgdn                                                    ** Pular entre tabs 


Bookmark - Control + F2 ( fazer a marcação)
           F2 (Para navegar)
           Shift + F2 (Desmarcar )
           Control + shift + F2 ( Para desmarcar tudo)

shift + alt + l                                                        ** Lorem Ipsum text

control+shift + L => cursor para cima e para baixo                     ** na realidade cursor no final das linhas 



Control + F9                                                           ** Ordem alfabetica um arquivo texto no sublime

Sublime package control instalado 
plugin   # BracketHighlighter
plugin alignment #git Gutter

alt+shift > alt+F                                                  ** Consigo navegar pelo menu bar 
Control+shift+P > menu > view:Toggle Menu                              ** Posso esconder o menu

control+H                                                          ** Faz replace

control+G                                                          ** Nós vamos para a linha definida

control + [                                                        ** Avançar linha
control + ]                                                        ** recuar linha 

control + shift + [                                                ** Encolher uma bloco de código
control + shift + ]                                                ** Expandir um bloco de código

Indo em  Preferences > Key binding podemos modificar a forma como se realiza commentários 

[
  {
      "keys": ["ctrl+1"],
      "command": "toggle_comment",
      "args": { "block": false } 
  }
  ,
  {   "keys": ["ctrl+shift+1"],
      "command": "toggle_comment",
      "args": { "block": true }
  }
]  

Manipulando TAGS

Control + SHIFT + J  => Selecionar elemento em mesma indentação

ALT + SHIFT + W  => Cria abre e fecha tags qualquer

CONTROL + 0      => Abre o menu com folders e files permitindo a seleção. 

Control + [ ou ] => Podemos pular as linhas por linhas vazias.

------------------------- >Terminal - Linux  -------------------------------------

>> https://canaltech.com.br/linux/entendendo-a-estrutura-de-diretorios-do-linux/
>> https://pt.wikibooks.org/wiki/Guia_do_Linux/Iniciante%2BIntermedi%C3%A1rio/Execu%C3%A7%C3%A3o_de_programas/path

Versões LTS - Long Term Suport                         ** Versões mas estáveis que não possuem atualizações de versão apenas algumas correções

zsh_reload                                             ** Plugin zshell para reload de página ( só rodar o comando src )

ctrl+alt+T                                             ** Atalho para o terminal
$ echo ~                                               ** Shell - pasta home - comando em programação para exibir o conteúdo de uma variável.
sudo touch "nomeDoArquivo"                             ** Criar arquivo 
ls                                                     ** Faz a listagem das pastas e arquivos do diretório.
ls -p                                                  ** Faz a listagem das pastas
mv                                                     ** Mover ou renomear um arquivo. mv nomeOrigem nomeDestino
man - é um comando de glossaryo irá postar os detalhes do commando que você
deseja empregar.
rm -R                                                  ** é um comando que remove diretório com arquivos
sudo -s  ou sudo sudo                                  ** manter o modo administrador
which <command>                                        ** Comando que mostrar o caminho de outros comandos
env | grep PATH                                        ** Mostra todos os caminhos criados no PATH
ps aux                                                 ** Lista todos os processos 
ln -s <arq1> <arq2>                                    ** Criando um arquivo simbolico
sudo apt install silversearcher                        ** Instalação igual ao grep só que melhor.
ps aux | ag bash | awk '{ print $1 }'                  ** Usando pipe para multiplos comandos ps depois uma busca igual a grep com ag e awk para selecionar coluna  

sudo apt-get upgrade                                   ** Fazer atualização de  todos os programas do desk 
set | less                                             ** Todos os comando bash e.g $USER

subl                                                   ** Chamar o sublime
pwd                                                    ** Imprimir na tela seu caminho atual.
lsb_release -a  | grep Release                         ** Conferir a versao linux - Ubuntu 19.10
ruby -v                                                ** ruby 2.5.5p157
gem -v                                                 ** 3.1.2
rvm list know                                          ** lista todas as versões ruby para mais de um sistema
cd /                                                   ** Comando que direciona para o diretório raiz
ll                                                     ** Lista os arquivos com seus permissões

oh my Zsh                                              ** Site para customizar a bash 

/usr/bin                                               ** Encontra-se o binários dos comandos básicos do shell
echo $PATH                                             ** Mostras os caminhos (Variáveis de ambiente)
echo $GEM_PATH                                         ** Mostra o caminho das gems 

find 

find . -name arquivo.txt                               ** Busca Simples de arquivo - o ponto indica para buscar no diretório atual e seus sub-diretórios 
find . -iname arquivo.txt                              ** Busca Simples de arquivo - ignora case-sensitive.
find . -depth -name diretorio arquivo.txt              ** Busca Simples de diretorio de arquivo especificado.
find /Documentos/ -name *rquivo*                       ** Busca Com coringas - Basicamente vc não sabe o nome ao certo
find . -depth -name *.txt                              ** Busca todos os arquivos de tipo txt
find . -type f -perm 0777 -print                       ** Busca todos os arquivos com permissão 0777
find . -type f ! -perm 777                             ** Busca todos os aquivos que não possuem a permisão 777
find /Documentos/Livros/ -empty                        ** Busca diretórios vazios
find /Documentos/Livros/ -type d -empty                ** Procura sódiretórios vazios
find /Documentos/Livros/ -type f -empty                ** Procura só arquivos
find . -type f -name ".*"                              ** Procurar arquivos ocultos
find . -type f -size +10M                              ** Procurar arquivos com mais de 10 MegaBytes
find . -type f -size -10M                              ** Procurar arquivos com menos de 10 MegaBytes
find /Downloads/ -tyoe f -name caelum-ux-usabilidade-wd41.pdf -exec rm -f {} \;                   ** Usando o -exec irá ser executado a remoção do arquivo
find . -type f -name arquivo.txt | xargs rm -f 
find . -name "*.*" -exec grep -Hin "Ana" {}\;          **Procurar por arquivos caso haja o nome informado dentro
find / -user bandit7 -group bandit6 size 33c 

grep 

grep -exec -l "millionth" data.txt                     **Procurar palavra especifica em arquivo

sort                                                   ** Ordena palavras dentro de arquivo

uniq -u                                                ** Faz uma busca de palavras que não se repetem

sleep 5                                                ** "Adormece" o sistema por 5 segundos
 
uname -r                                               ** ver a versão kernel linux
uname -m
  
ps -ef                                                 ** Pesquisar.

sudo dpkg -i arquivo.deb                               ** Instalando um package no linux
sudo gdebi skype.deb                                   ** Instalando uma packge na Distro Ubuntu
sudo tar -vzxf <arquivo.tar.gz)                        ** descompactar arquivo tar.gz


lsb_release  -a                                        ** Versão da distro linux
ls -h                                                  ** ls human podemos visualizar o size em MB


du -sh /var/cache/apt/archives                         ** Verificar tamanho de dados temporaŕios no sistema
du -hs                                                 ** sumariza o total de tamanho da pasta inteira 
sudo apt install bleachbit                             ** pacote de limpeza

id                                                     ** mostra o usuário corrente

sudo snap install heroku --class                       ** Instalando CLI heroku

sudo apt-add-repository --remove https://download.sublimetext.com apt/     ** Caso necessite eliminar um ppa de atualizar no apt update

ip addr                                                ** Possibilita a visualzação de detalhes de dispositivo em rede. 

sudo snap remove postman
sudo snap install postman

cat /etc/passwd                                        ** Dados do usuário
hitory -E | less                                       ** fazer a exibição de histórico humanizado no zsh com less
rm -rf /                                               ** É UMA BOMBA PARA SEU PC elimina tudo no diretório raiz 

export TMOUT=10                                        ** Desloga durante um tempo                                   
set | less                                             ** você conseguirá ver as variáveis de ambiente

echo $UID                                              ** Id do usuário no sistema

grep jorgeborges /etc/passwd                           ** O grep captura uma linha localizada por uma busca em arquivo

ls -ln                                                 ** Faz uma listagem por número de id de usuários
0                                                      ** Sempre é o id do root

echo $PS1                                              ** customiza o shell
$PS2                                                   ** \ pula linha 
$PS3
$PS4 


alias ls="ls -l"                                       ** Simplificação renomeando

.bashrc                                                ** É um arquivo de sessão para shell não login, quando não precisa de login
.profile                                               ** É executado para shell que precisa de login

which cp 
/usr/bin/cp 
less /usr/bin/cp                                       ** Além de um caminho

vim sshd_config                                        ** Configuração de segurança do ssh

/usr/local/sbin                                        ** Onde ficam os bin de super usuário

tar                                                    ** É um arquivador

echo $?                                                ** verifica se os programas executaram 0 é sucesso e 1 é falha

echo -e "Bom dia\nfulano"                              ** quebra de linha dentro do echo

echo -e $'$custom-purple: #694ED8 \n$cutom-purple-dark: #6600CC !default;' >> src/styles/_custom_color.scss  ** caso texto haja caracteres especiais como dolar

sudo apt-get install xclip                             ** Fazer buffer de seleção 

pwd | xclip -sel clip                                  ** Agora você pode copiar a saida de um comando e logo depois colar normalmente em outro local.


head -n 1 /etc/passwd                                  => Comando que pega as 10 primeiras linhas de um arquivo
root:x:0:0:root:/root:/usr/bin/zsh                     => Essa seria a saida onde x significa que a senha está criptografado e em outro local /etc/shadowuse
/etc/shadow                                            => Onde encotram-se as senhas
/etc/gshadow
/etc/group
$ pwunconv
$ pwconv                                           
useradd -u <pode_ser_espedificado_o_id_usuario> -g <pode_ser_especificado_o_group> -c <adicionar_comentário> <nome>             => Adicionar um usuário

passwd                                                 => Modifica a senha do usuário corrente
passwd  -e                                             => Expire, expirar senha
passwd -de                                             => Deletando e expirando a senha
passwd -l                                              => Lock a conta, o user, bloqueia
passwd -u                                              => Faz o unlock para desbloquear o user 
chage -l <nome_do_usuário>                             => Mostra várias informações do user $ chage -l jorgeborges
adduser                                                => diferente do useradd, é mais automático
userdel   -r <podemos_remover_os_diretorios_do_user>   => remove o usuário
usermod                                                => Modificar dados de um usuário
groupadd  <nome_do_grupo>
groupdel  <nome_do_grupo>
gpasswd -a <nome_do_usuário_que_deseja_adicionar> <nome_do_grupo>
gpasswd -d <nome_do_usuário_que_deseja_adicionar> <nome_do_grupo_que_deseja_remover_este_usuário>

*Permissões

r => 4
w => 2
x => 1

r => read
w => write
x => execution

a => todos
u => usuário dono
g => grupo
o => outros

chmod => modifica as permissões dos arquivos e diretórios
chown => modifica a permissão dono ou/o grupo do arquivo/diretorio.

-rwxrwxrwx => permissão 777  / um aarquivo texto
lrwxwrwxrwx => um arquivo de link simbolico
drwxwrwxrwx => um diretorFio
crwxwrwxrwx => arquivo de character
brwxwrwxrwx => disp Bloco do hd;

 
-rw-r--r-- => 644         / contado a permissão r => 4 , w => 2 e x => 1

chmod o-x                 / remover permissão de outros
chmod g+x                 / adicionando permissão de execução para os grupos
chmod a=rw                / todos com permissão rw
chmod -R 777              / mudando a permissão de todos as subpastas de um diretório; R é de recursivo  

chown <nome_user> <arquivo>              / ch=change - own = dono;  mudar o dono do arquivo
chown :<nome_grupo> <arquivo>            / mudar o dono grupo do arquivo
chown root:root <arquivo>                / mudar o user dono e o dono do grupo de uma vez.

getfacl    => informações                           
setfacl    => posso modificar arquivos de forma que usuário de grupos diferentes possam ter permisão de modificar o arquivo

top                                                     => Mostra dados da máquina
       
sudo ufw app list                                       => O comando ufw é de acesso e configuração do firewall tem ser habilitado

alias custom_bash="subl ~/.zshrc"                       => alias para customizar o zshell
alias go_to_main="cd ~/Documents"

------------------------------------------Tilix - Terminal Emulator   -------------------------------------------------------------

control + shift + A                                    => Mostrar o painel de atalho ( Criado pelo usuário )




------------------------------------------Tmux - >Vim -------------------------------------------------------------

                        VIM 
                                                                         k
      Move around:  Use the cursor keys, or "h" to go left,            h   l
                    "j" to go down, "k" to go up, "l" to go right.       j
Close this window:  Use ":q<Enter>".
   Get out of Vim:  Use ":qa!<Enter>" (careful, all changes are lost!).

Jump to a subject:  Position the cursor on a tag (e.g. bars) and hit CTRL-].
   With the mouse:  ":set mouse=a" to enable the mouse (in xterm or GUI).
                    Double-click the left mouse button on a tag, e.g. bars.
        Jump back:  Type CTRL-O.  Repeat to go further back.

Get specific help:  It is possible to go directly to whatever you want help
                    on, by giving an argument to the :help command.
                    Prepend something to specify the context:  help-context




                      Normal mode command                  :help x
                      Visual mode command         v_       :help v_u
                      Insert mode command         i_       :help i_<Esc>
                      Command-line command        :        :help :quit
                      Command-line editing        c_       :help c_<Del>
                      Vim command argument        -        :help -r
                      Option                      '        :help 'textwidth'
                      Regular expression          /        :help /[

i                    => Começar a inserir 
I                    => Ele começa a inserir no inicio da linha
a                    => Começa a inserior o caracter seguinte
A                    => Começa no final da linha.
S                    => Apaga linha inteira e começa uma inserção
:w                   => Salva o arquivo
:wq                  => Salva e sair
:q!                  => Sair sem salva
:x                   => Salvar e sair 
shift + ZZ           => Salvar e sair (comando mais rápido) 
yy                   => Copiar uma linha (2 yy) ou (3 yy) multiplas linhas
p                    => Colar
dd                   => recortar linha e para colar é o p.
:[start],[final]d    => é possível remover múltiplas linhas.

d                    => deleta.
v                    => modo visual ( Agora você conseguirá selecionar trechos de código com as *setas - não o mouse)
y                    => No modo visual copia
p                    => Cola no modo visual
control+v            => Modo visual vertical

yw                   => copia uma palavra, só lembrar que o cursor ficará na frente da palavra. ( 3yw, 4yw - copia 3 e 4 palavras)
x                    => você conseguirá fazer um backspace ou deletar.
:w <nome>            => É como um salvar como, fique atento vc irá criar um novo arquivo.
:split <arquivo>     => Consigo fazer a divisão do vim com para dois arquivos
control + ww         => pula de uma tab para outra.
:r /etc/hosts        => basicamente ele faz a leitura de um arquivo e joga no seu arquivo.
/<uma palavra> + enter     => Essa é a busca no vim
?<palavra>           => Irá fazer uma busca de baixo para cima.
n                    => Irá pular os valores das buscas. 


:1,10s /<palavra antiga>/<palavra nova>   => Basicamente faz um replace seu arquivo, em um limite de linha, mas para só um elemento
:1,10s /<palavra antiga>/<palavra nova>/g   => Basicamente faz um replace em todo o seu arquivo, em um limite de linha, de todos os elementos.

:%s /<palavra antiga>/<palavra nova>     => Basicamente faz um replace em todo o seu arquivo
:%s/<palavra antiga>/<palavra nova>/g    => com o g no final substituira toda as palavras mesmo com as repetições em uma linha


:e <novo_arquivo_que_vc_quer_abrir>      => Abrindo um novo arquivo

:syntax on           => Liga o reconhecimento de sysntax on 
:syntax o            => Desliga

:set number          => Adiciona a numeração das linhas uma referência
:set nonu            => desabilitar a numeração 

:ab <novoatalho> <umaPalavra_que_voce_deseja_substituir>               => Criando atalho

:noh                 => Remove hilight de search

:set ai              => Auto identação.
:set noai            => Desativando a auto-identação.
:set visualbell      => Não irá mais fazer barulho de alerta. 
:set ic              => torna a busca sem ser case sesnitive 
:set tabstop=2       => Definir tamanho do tab
:set showmatch       => Ele irá destacar as chaves quando abre e fecha

:.,$!sort            => colocar em ordem alfabetica
u                    => desfaz
control+r            => refaz 

:.,$!sort | pr -2t   => ordena e divide em duas colunas ( t é para não trazer o título )

control + s          => Modo superUser para sair digite control+q

Configurando o vim:

homw/.vimrc

colorscheme blue
set tabstop=2
set number
set cursorline
set showcmd
set hlsearch
set autoindent
syntax on
set visaulbell
set showmatch

set nocompatible

filetype off

set rtp+=~/.vim/bundle/Vundle.vim

call vundle#begin()

Plugin 'VundleVim/Vundle.vim'

"----- VIM appearence -----
Plugin 'altercation/vim-colors-solarized'
Plugin 'tomasr/molokai'
Plugin 'vim-airline/vim-airline'
Plugin 'vim-airline/vim-airline-themes'

" ----- Vim as a programmer's text editor -----------------------------
Plugin 'scrooloose/nerdtree'
Plugin 'jistr/vim-nerdtree-tabs'

"----- Working with Git ----------------------------------------------
Plugin 'tpope/vim-fugitive'

" ----- Other text editing features -----------------------------------
Plugin 'Raimondi/delimitMate'

Plugin 'christoomey/vim-tmux-navigator' " --- TMUX
Plugin 'tpope/vim-rails' " --- Rails
Plugin 'tpope/vim-dispatch'


call vundle#end()

filetype plugin indent on

" --- General Settings ---
set backspace=indent,eol,start
set ruler
set number
set showcmd
set incsearch
set hlsearch
set tabstop=2

syntax on
syntax enable
set background=dark
let g:solarized_termcolors=256
colorscheme solarized
set laststatus=2
let g:airline_detect_paste=1
let g:airline#extensions#tabline#enabled = 1
let g:airline_theme='solarized'

" ----- jistr/vim-nerdtree-tabs -----
" Open/close NERDTree Tabs with \t
nmap <silent> <leader>t :NERDTreeTabsToggle<CR>
" To have NERDTree always open on startup
let g:nerdtree_tabs_open_on_console_startup = 1
" ----- Raimondi/delimitMate settings -----

let delimitMate_expand_cr = 1
augroup mydelimitMate
  au!
  au FileType markdown let b:delimitMate_nesting_quotes = ["`"]
  au FileType tex let b:delimitMate_quotes = ""
  au FileType tex let b:delimitMate_matchpairs = "(:),[:],{:},`:'"
  au FileType python let b:delimitMate_nesting_quotes = ['"', "'"]
augroup END

set mouse=a











============================

Wargames 
ssh leviathan1@leviathan.labs.overthewire.org -p 2223

leviatnan1 - ~/.backup$ grep leviathan bookmarks.html => rioGegei8m 
leviathan2 - ougahZi8Ta (ltrace) - whoami
leviathan3 - realizar um link simbólico => Ahdiemoo1j 





Rails Summit 2009 -

Marcos Tapajós
Damien Katz - CounchDB
Load Balancers
MVCC - Mult version 

Vinicius Teles 

Rich Kilmer

---------------------------------------

###### Editor to big files - VIM ######

open vim - vim /path/to/file.txt
i        - Unlock editor
esc      - Exit editor
:wq      - Quit vim

######################## Other tips ########################

* get your own ip
ifconfig | grep "inet " | grep -v 127.0.0.1

* kill all process related to port X
lsof -t -i tcp:X | xargs kill

* Fix openssl issue
brew switch openssl 1.0.2t

* How install openssl
	- 1.0 (because is no more available)
		brew uninstall openssl; brew uninstall openssl; brew install https://github.com/tebelorg/Tump/releases/download/v1.0.0/openssl.rb; brew switch openssl 1.0.2t
	- 1.1 (because is no more available)
		brew install https://raw.githubusercontent.com/Homebrew/homebrew-core/8b9d6d688f483a0f33fcfc93d433de501b9c3513/Formula/openssl.rb

* Convert xlsx to csv
ssconvert Book1.xlsx newfile.csv
/\ To install in mac: brew install gnumeric | To install in Linux: apt-get install gnumeric

* Completely remove Xcode and CLT from MacOS
rm -rf /Applications/Xcode.app ~/Library/Caches/com.apple.dt.Xcode ~/Library/Developer ~/Library/MobileDevice ~/Library/Preferences/com.apple.dt.Xcode.plist ~/Library/Preferences/com.apple.dt.Xcode.plist /System/Library/Receipts/com.apple.pkg.XcodeExtensionSupport.bom /System/Library/Receipts/com.apple.pkg.XcodeExtensionSupport.plist /System/Library/Receipts/com.apple.pkg.XcodeSystemResources.bom /System/Library/Receipts/com.apple.pkg.XcodeSystemResources.plist /private/var/db/receipts/com.apple.pkg.Xcode.bom /Library/Developer/CommandLineTools

* Install rvm ruby 2.1.3 on Big Sur
CFLAGS="-Wno-error=implicit-function-declaration" rvm install 2.1.3 --disable-binary --with-openssl-dir=$(brew --prefix openssl@1.0)

* Install rmagick with imagemagick@6
PKG_CONFIG_PATH=/usr/local/Cellar/imagemagick@6/6.9.12-7/lib/pkgconfig/ gem install rmagick -v '2.13.4'

* Install mysql2:
- Mac
gem install mysql2 -v '0.3.19' -- --with-ldflags=-L/usr/local/opt/openssl/lib --with-cppflags=-I/usr/local/opt/openssl/include
or if mysql@5.6 is updated to 5.6.46, reverting to 5.6.43 \/
brew reinstall https://raw.githubusercontent.com/Homebrew/homebrew-core/f171f1c74/Formula/mysql@5.6.rb
brew pin mysql@5.6
- Linux
sudo apt-get install libmysqlclient-dev

* Install nokogiri
brew install libxml2
gem install nokogiri -v '1.6.6.2' -- --use-system-libraries --with-xml2-include=/usr/local/opt/libxml2/include/libxml2
or
gem install nokogiri -v '1.6.8' -- --use-system-libraries --with-xml2-dir=$(brew --prefix libxml2) --with-xslt-dir=$(brew --prefix libxslt)

* Install puma
gem install puma -v '3.4.0' -- --with-opt-dir=$(brew --prefix openssl@1.0)

* Install ffi
brew install automake autoconf libtool
gem install ffi -v '1.9.21' -- --with-cflags="-Wno-error=implicit-function-declaration"

* Library not loaded: /usr/local/opt/readline/lib/libreadline.7.dylib
ln -s /usr/local/opt/readline/lib/libreadline.8.0.dylib /usr/local/opt/readline/lib/libreadline.7.dylib
or
ln -s /usr/local/opt/readline/lib/libreadline.7.0.dylib /usr/local/opt/readline/lib/libreadline.6.dylib

* Download Audio (MP3) from any video in anywhere
youtube-dl --audio-format mp3 -o '~/Music/Musics/%(title)s.%(ext)s' -x URL
youtube-dl --audio-format mp3 -o '~/Music/%(playlist)s/%(playlist_index)s - %(title)s.%(ext)s' -x URL_PLAYLIST

youtube-dl.exe --audio-format mp3 --playlist-start 1 --playlist-end 79 -o "C:\%HOMEPATH%\Desktop\%%(playlist)s/%%(playlist_index)s - %%(title)s.%%(ext)s" -x URL_PLAYLIST

* Download Video (MP4) from any video in anywhere
youtube-dl --format mp4 -o '~/Movies/%(title)s.%(ext)s' URL

* My hack challenge
http://hackchallenger.rf.gd/

################ Install Ruby/RVM/Rails/Git ################

https://gorails.com/setup/ubuntu/17.04

##################### Sublime Packages #####################

A File Icon
Alignment
All Autocomplete
GitGutter
BracketHighlighter
Color Highlight
Sass
Pretty JSON
Pretty Ruby
JSON Reindent
Indent XML
Better CoffeeScript
SublimeLinter-haml

########################### RVM ############################

rvm get master => Get lastiest version of rvm

* try update certificates if can't connect to source rubygem
rvm osx-ssl-certs status all
rvm osx-ssl-certs update all

* Install using old openssl
rvm install ruby-2.1.4 --with-openssl-dir='/usr/local/opt/openssl@1.0'

############### My Personal Updates in Mac ###############

http://bashrcgenerator.com/  => Create your own bash config code

- Add new command in last line of bash_profile
echo 'alias <command-name>="<command-action>"' >> ~/.bash_profile

- Install gitx
brew install --cask rowanj-gitx

- My Oh-My-Zsh Config
  ZSH_THEME="af-magic"
  plugins=(
    git
    bundler
    rake
    rvm
    ruby
    brew
    zsh-syntax-highlighting
    zsh_reload
  )