update pt-BR book

pt-BR/book/carregando_dados.md

@@ -7,25 +7,25 @@ Anteriormente vimos como você pode usar comandos como `ls`, `ps`, `date` e `sys
 Uma das funcionalidades mais poderosas do Nu para lidar com dados é o comando `open`. Ele é uma ferramenta múltipla, capaz de trabalhar com diversos formatos de dados. Para vermos o que isso significa, vamos tentar abrir um arquivo json:
 
 ```nu
-> open editors/vscode/package.json
-------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
- name | descript | author   | license | version | reposito | publishe | categori | keywords | engines  | activati | main     | contribu | scripts  | devDepen
-      | ion      |          |         |         | ry       | r        | es       |          |          | onEvents |          | tes      |          | dencies
-------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
- lark | Lark     | Lark     | MIT     | 1.0.0   | [object] | vscode   | [0       | [1 item] | [object] | [1 item] | ./out/ex | [object] | [object] | [object]
-      | support  | develope |         |         |          |          | items]   |          |          |          | tension  |          |          |
-      | for VS   | rs       |         |         |          |          |          |          |          |          |          |          |          |
-      | Code     |          |         |         |          |          |          |          |          |          |          |          |          |
-------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
+open editors/vscode/package.json
+# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
+# =>  name | descript | author   | license | version | reposito | publishe | categori | keywords | engines  | activati | main     | contribu | scripts  | devDepen
+# =>       | ion      |          |         |         | ry       | r        | es       |          |          | onEvents |          | tes      |          | dencies
+# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
+# =>  lark | Lark     | Lark     | MIT     | 1.0.0   | [object] | vscode   | [0       | [1 item] | [object] | [1 item] | ./out/ex | [object] | [object] | [object]
+# =>       | support  | develope |         |         |          |          | items]   |          |          |          | tension  |          |          |
+# =>       | for VS   | rs       |         |         |          |          |          |          |          |          |          |          |          |
+# =>       | Code     |          |         |         |          |          |          |          |          |          |          |          |          |
+# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
 ```
 
 De um jeito similar ao comando `ls`, abrir um tipo de arquivo que o Nu entende vai nos retornar algo que é mais do que apenas texto (ou um fluxo de bytes). Aqui nós abrimos um arquivo "package.json" de um projeto JavaScript. O Nu abre e reconhece o texto JSON e retorna uma tabela de dados.
 
 Se quisermos checar a versão do projeto que estamos olhando, podemos usar o comando `get`.
 
 ```nu
-> open editors/vscode/package.json | get version
-1.0.0
+open editors/vscode/package.json | get version
+# => 1.0.0
 ```
 
 O Nu atualmente suporta carregar dados diretamente para tabelas a partir dos seguintes formatos:
@@ -40,7 +40,7 @@ O Nu atualmente suporta carregar dados diretamente para tabelas a partir dos seg
 Mas o que acontece se você carregar um arquivo texto cujo formato não é um desses? Vamos tentar:
 
 ```nu
-> open README.md
+open README.md
 ```
 
 O conteúdo do arquivo é mostrado. Se o arquivo for muito grande, obteremos uma visão rolável para examinar o arquivo e depois voltar para o terminal. Para ajudar na legibilidade, Nu faz realce de sintaxe para formatos comuns como arquivos de código fonte, markdown e outros.
@@ -54,90 +54,90 @@ Uma parte importante de se trabalhar com dados vindos de fora do Nu é que eles
 Vamos imaginar que obtivemos esse arquivo de dados:
 
 ```nu
-> open people.txt
-Octavia | Butler | Writer
-Bob | Ross | Painter
-Antonio | Vivaldi | Composer
+open people.txt
+# => Octavia | Butler | Writer
+# => Bob | Ross | Painter
+# => Antonio | Vivaldi | Composer
 ```
 
 Cada pedacinho de dado que queremos está separado pelo símbolo de pipe ('|') e cada pessoa está numa linha em separado. Nu não possui por padrão um formato de arquivos delimitados por pipe, então teremos que interpretá-lo nós mesmos.
 
 A primeira coisa que queremos fazer ao carregar o arquivo é trabalhar com ele linha a linha:
 
 ```nu
-> open people.txt | lines
----+------------------------------
- # | value
----+------------------------------
- 0 | Octavia | Butler | Writer
- 1 | Bob | Ross | Painter
- 2 | Antonio | Vivaldi | Composer
----+------------------------------
+open people.txt | lines
+# => ---+------------------------------
+# =>  # | value
+# => ---+------------------------------
+# =>  0 | Octavia | Butler | Writer
+# =>  1 | Bob | Ross | Painter
+# =>  2 | Antonio | Vivaldi | Composer
+# => ---+------------------------------
 ```
 
 Podemos notar que estamos lidando com linhas porque voltamos a ver uma lista. Nosso próximo passo é tentar dividir as linhas em algo um pouco mais útil. Para isso, vamos usar o comando `split column`. Como o nome implica, esse comando nos dá uma forma de dividir em colunas uma string delimitada. Informamos qual é o delimitador e o comando faz o resto:
 
 ```nu
-> open people.txt | lines | split column "|"
----+----------+-----------+-----------
- # | Column1  | Column2   | Column3
----+----------+-----------+-----------
- 0 | Octavia  |  Butler   |  Writer
- 1 | Bob      |  Ross     |  Painter
- 2 | Antonio  |  Vivaldi  |  Composer
----+----------+-----------+-----------
+open people.txt | lines | split column "|"
+# => ---+----------+-----------+-----------
+# =>  # | Column1  | Column2   | Column3
+# => ---+----------+-----------+-----------
+# =>  0 | Octavia  |  Butler   |  Writer
+# =>  1 | Bob      |  Ross     |  Painter
+# =>  2 | Antonio  |  Vivaldi  |  Composer
+# => ---+----------+-----------+-----------
 ```
 
 Está quase certo. Parece que tem um espaço extra ali. Vamos mudar nosso delimitador:
 
 ```nu
-> open people.txt | lines | split column " | "
----+---------+---------+----------
- # | Column1 | Column2 | Column3
----+---------+---------+----------
- 0 | Octavia | Butler  | Writer
- 1 | Bob     | Ross    | Painter
- 2 | Antonio | Vivaldi | Composer
----+---------+---------+----------
+open people.txt | lines | split column " | "
+# => ---+---------+---------+----------
+# =>  # | Column1 | Column2 | Column3
+# => ---+---------+---------+----------
+# =>  0 | Octavia | Butler  | Writer
+# =>  1 | Bob     | Ross    | Painter
+# =>  2 | Antonio | Vivaldi | Composer
+# => ---+---------+---------+----------
 ```
 
 Nada mal. O comando `split column` retorna dados que podemos usar. Ele também vai além e nos dá nomes de coluna padrão:
 
 ```nu
-> open people.txt | lines | split column " | " | get Column1
----+---------
- # | value
----+---------
- 0 | Octavia
- 1 | Bob
- 2 | Antonio
----+---------
+open people.txt | lines | split column " | " | get Column1
+# => ---+---------
+# =>  # | value
+# => ---+---------
+# =>  0 | Octavia
+# =>  1 | Bob
+# =>  2 | Antonio
+# => ---+---------
 ```
 
 Podemos também nomear nossas colunas ao invés de usar os nomes padrão:
 
 ```nu
-> open people.txt | lines | split column " | " first_name last_name job
----+------------+-----------+----------
- # | first_name | last_name | job
----+------------+-----------+----------
- 0 | Octavia    | Butler    | Writer
- 1 | Bob        | Ross      | Painter
- 2 | Antonio    | Vivaldi   | Composer
----+------------+-----------+----------
+open people.txt | lines | split column " | " first_name last_name job
+# => ---+------------+-----------+----------
+# =>  # | first_name | last_name | job
+# => ---+------------+-----------+----------
+# =>  0 | Octavia    | Butler    | Writer
+# =>  1 | Bob        | Ross      | Painter
+# =>  2 | Antonio    | Vivaldi   | Composer
+# => ---+------------+-----------+----------
 ```
 
 Agora que nossos dados estão em uma tabela, podemos usar todos os comandos que já usávamos antes em tabelas:
 
 ```nu
-> open people.txt | lines | split column " | " first_name last_name job | sort-by first_name
----+------------+-----------+----------
- # | first_name | last_name | job
----+------------+-----------+----------
- 0 | Antonio    | Vivaldi   | Composer
- 1 | Bob        | Ross      | Painter
- 2 | Octavia    | Butler    | Writer
----+------------+-----------+----------
+open people.txt | lines | split column " | " first_name last_name job | sort-by first_name
+# => ---+------------+-----------+----------
+# =>  # | first_name | last_name | job
+# => ---+------------+-----------+----------
+# =>  0 | Antonio    | Vivaldi   | Composer
+# =>  1 | Bob        | Ross      | Painter
+# =>  2 | Octavia    | Butler    | Writer
+# => ---+------------+-----------+----------
 ```
 
 Há outros comandos que você pode usar para trabalhar com strings:
@@ -149,23 +149,23 @@ Há outros comandos que você pode usar para trabalhar com strings:
 Há também um conjunto de comandos auxiliares que podemos chamar se soubermos que os dados têm uma estrutura que o Nu deve ser capaz de entender. Por exemplo, vamos abrir um arquivo de lock do Rust:
 
 ```nu
-> open Cargo.lock
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "adhoc_derive"
-version = "0.1.2"
+open Cargo.lock
+# => # This file is automatically @generated by Cargo.
+# => # It is not intended for manual editing.
+# => [[package]]
+# => name = "adhoc_derive"
+# => version = "0.1.2"
 ```
 
 O arquivo "Cargo.lock" é na verdade um arquivo .toml, mas a extensão do arquivo não é .toml. Tudo bem, podemos usar o comando `from toml`:
 
 ```nu
-> open Cargo.lock | from toml
-----------+-------------
- metadata | package
-----------+-------------
- [object] | [405 items]
-----------+-------------
+open Cargo.lock | from toml
+# => ----------+-------------
+# =>  metadata | package
+# => ----------+-------------
+# =>  [object] | [405 items]
+# => ----------+-------------
 ```
 
 Há um comando `from` para cada formato de dados estruturados em texto que o Nu entende e pode abrir.
@@ -175,23 +175,23 @@ Há um comando `from` para cada formato de dados estruturados em texto que o Nu
 Embora seja útil poder abrir um arquivo e trabalhar imediatamente com uma tabela dos seus dados, nem sempre é isso o que queremos fazer. Para ter acesso ao texto subjacente, o comando `open` pode receber um modificador opcional `--raw`:
 
 ```nu
-> open Cargo.toml --raw
-[package]                                                                                        name = "nu"
-version = "0.1.3"
-authors = ["Yehuda Katz <[email protected]>", "Sophia Turner <[email protected]>"]
-description = "A shell for the GitHub era"
-license = "MIT"
+open Cargo.toml --raw
+# => [package]                                                                                        name = "nu"
+# => version = "0.1.3"
+# => authors = ["Yehuda Katz <[email protected]>", "Sophia Turner <[email protected]>"]
+# => description = "A shell for the GitHub era"
+# => license = "MIT"
 ```
 
 ## Abrindo URLs
 
 Além de carregar dados a partir do sistema de arquivos, você também pode passar uma URL para o comando `open`. Ele trará da internet o conteúdo dessa URL e o retornará para você:
 
 ```nu
-> open https://www.jonathanturner.org/feed.xml
-----------
- rss
-----------
- [1 item]
-----------
+open https://www.jonathanturner.org/feed.xml
+# => ----------
+# =>  rss
+# => ----------
+# =>  [1 item]
+# => ----------
 ```

pt-BR/book/escapando.md

@@ -5,11 +5,11 @@ O Nu fornece um conjunto de comandos que você pode usar entre diferentes SOs e
 Comando Nu:
 
 ```nu
-> ls
+ls
 ```
 
 Escapando para o comando local:
 
 ```nu
-> ^ls
+^ls
 ```

pt-BR/book/explorando.md

@@ -11,38 +11,38 @@ Como vimos em outros capítulos, `ls` é um comando para visualizar o conteúdo
 O comando `ls` também recebe um parâmetro opcional para mudar o que você gostaria de ver. Por exemplo, podemos listar os arquivos cujo nome termina em ".txt".
 
 ```nu
-> ls *.txt
----+--------------+------+----------+---------+--------------+--------------
- # | name         | type | readonly | size    | accessed     | modified
----+--------------+------+----------+---------+--------------+--------------
- 0 | history.txt  | File |          | 1.3 KB  | 2 months ago | a day ago
- 1 | readonly.txt | File | readonly | <empty> | 2 months ago | 2 months ago
----+--------------+------+----------+---------+--------------+--------------
+ls *.txt
+# => ---+--------------+------+----------+---------+--------------+--------------
+# =>  # | name         | type | readonly | size    | accessed     | modified
+# => ---+--------------+------+----------+---------+--------------+--------------
+# =>  0 | history.txt  | File |          | 1.3 KB  | 2 months ago | a day ago
+# =>  1 | readonly.txt | File | readonly | <empty> | 2 months ago | 2 months ago
+# => ---+--------------+------+----------+---------+--------------+--------------
 ```
 
 O asterisco (\*) usado no parâmetro opcional acima "\*.txt" é chamado de coringa. Ele faz uma correspondência com qualquer coisa. Você pode ler o coringa "\*.txt" como "aceite qualquer nome de arquivo, desde que termine com '.txt'".
 
 Nu também usa coringas modernos, que permitem acesso a diretórios mais profundos.
 
 ```nu
-> ls **/*.rs
------+-----------------------------------------------------+------+----------+----------+----------------+----------------
- #   | name                                                | type | readonly | size     | accessed       | modified
------+-----------------------------------------------------+------+----------+----------+----------------+----------------
- 0   | src/cli.rs                                          | File |          | 19.1 KB  | 15 hours ago   | 15 hours ago
- 1   | src/commands/args.rs                                | File |          | 244 B    | 2 months ago   | 2 months ago
- 2   | src/commands/autoview.rs                            | File |          | 2.5 KB   | 15 hours ago   | 15 hours ago
- 3   | src/commands/cd.rs                                  | File |          | 277 B    | a week ago     | a week ago
- 4   | src/commands/classified.rs                          | File |          | 13.5 KB  | 15 hours ago   | 15 hours ago
- 5   | src/commands/clip.rs                                | File |          | 2.0 KB   | 2 days ago     | 2 days ago
+ls **/*.rs
+# => -----+-----------------------------------------------------+------+----------+----------+----------------+----------------
+# =>  #   | name                                                | type | readonly | size     | accessed       | modified
+# => -----+-----------------------------------------------------+------+----------+----------+----------------+----------------
+# =>  0   | src/cli.rs                                          | File |          | 19.1 KB  | 15 hours ago   | 15 hours ago
+# =>  1   | src/commands/args.rs                                | File |          | 244 B    | 2 months ago   | 2 months ago
+# =>  2   | src/commands/autoview.rs                            | File |          | 2.5 KB   | 15 hours ago   | 15 hours ago
+# =>  3   | src/commands/cd.rs                                  | File |          | 277 B    | a week ago     | a week ago
+# =>  4   | src/commands/classified.rs                          | File |          | 13.5 KB  | 15 hours ago   | 15 hours ago
+# =>  5   | src/commands/clip.rs                                | File |          | 2.0 KB   | 2 days ago     | 2 days ago
 ```
 
 Aqui estamos procurando qualquer arquivo cujo nome termine com ".rs" e os dois asteriscos dizem ainda "em qualquer diretório começando a partir daqui".
 
 ## Mudando o diretório atual
 
 ```nu
-> cd new_directory
+cd new_directory
 ```
 
 Para mudar do diretório atual para um outro, usamos o comando `cd`. Assim como em outros shells, podemos usar o nome do diretório ou, se quisermos ir para um diretório acima, podemos usar o atalho `..`.
@@ -54,25 +54,25 @@ Nu também fornece alguns comandos básicos de sistemas de arquivos que funciona
 Podemos mover um item de um lugar para outro usando o comando `mv`.
 
 ```nu
-> mv item location
+mv item location
 ```
 
 Podemos copiar um item de um local para outro:
 
 ```nu
-> cp item location
+cp item location
 ```
 
 Podemos remover um item:
 
 ```nu
-> rm item
+rm item
 ```
 
 Os três comandos também podem usar os coringas que vimos anteriormente com `ls`.
 
 Por fim, podemos criar um novo diretório usando o comando `mkdir`:
 
 ```nu
-> mkdir new_directory
+mkdir new_directory
 ```