Como aprender a ferrugem sem instalar nenhum software

PorAntónio César de Andrade 

fn main() {
    println!("Hello, world!");
}
O arquivo src / main.rs

Em seguida, volte para a raiz / diretório do repositório GitHub e adicione um Cargo.toml Arquivo. Este arquivo descreve como o sistema de carga Rust deve construir e empacotar nosso projeto.

[package]
name = "hello"
version = "0.1.0"
authors = ["ubuntu"]
edition = "2018"

[dependencies]
O arquivo Cargo.toml no diretório raiz do repositório

Agora temos um projeto completo de ferrugem. Vamos construir e executá-lo agora.

Ações do Github

Na guia Ações do GitHub, podemos adicionar fluxos de trabalho associados a este projeto. Essas são ações que o Github executa automaticamente quando certos eventos ocorrem, como envio ou confirmação de código. No nosso caso, gostaríamos que o GitHub crie e execute automaticamente nosso main.rse mostre-nos os resultados.

As ações do fluxo de trabalho e seus acionadores de eventos são definidos em yml arquivos sob o .github/workflows diretório. Você pode escrever o seu próprio yml arquivos ou escolha um dos modelos prontos.

O modelo de fluxo de trabalho Rust nas Ações do GitHub

Aqui escolhemos o modelo Rust. O GitHub permite editar o arquivo rust.yml antes de fazer o check-in no repositório.

O modelo de ações Rust padrão. Você pode editá-lo ao seu gosto.

Vamos dar um minuto aqui para explicar como as ações do GitHub funcionam. O padrão rust.yml arquivo diz que

  • Sempre que um usuário envia código ou aceita solicitações pull neste repositório, as ações neste rust.yml o fluxo de trabalho será acionado.
  • O fluxo de trabalho criará uma máquina virtual executando o sistema operacional Ubuntu mais recente. Neste sistema Ubuntu, ele executará as seguintes etapas.
  • Ele fará o checkout do código no master ramo.
  • Ele irá executar o cargo build --verbose comando para compilar e construir o código Rust.
  • Ele irá executar o cargo test --verbose comando para executar os casos de teste.
  • Todas as saídas padrão e de console no sistema Ubuntu dos dois comandos acima serão capturadas pelo GitHub Actions e exibidas na web.

Você pode editar a última linha em rust.yml atuar cargo run, que executa o programa binário compilado. Nosso atualizado rust.yml arquivo é o seguinte.

name: Rust

on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Build
      run: cargo build --verbose
    - name: Run
      run: cargo run
Alteramos a última linha do modelo Rust padrão para corrida de carga

Agora, sempre que você envia o código para este repositório, as ações em rust.yml são executadas. Você pode ver os resultados na guia Ações.

Cada push no repositório GitHub acionará as ações a serem executadas

Você pode clicar em um resultado e clicar na guia compilar à esquerda para ver os detalhes. As seções de construção e execução fornecem os detalhes mais relevantes. A seção Executar mostra a impressão bem-sucedida do hello world!

A ação Executar mostra Hello World! impresso para o console!

Em seguida, você pode adicionar dependências de terceiros em Cargo.tomle crie aplicativos Rust complexos em main.rs. Toda vez que alguém envia um código, poderemos ver os resultados.

Desenvolvimento Orientado a Testes (TDD)

Obviamente, muito poucos desenvolvedores realmente executam seus programas para imprimir texto no console. o cargo run acima é apenas um show. Na realidade, a maioria dos desenvolvedores escreve funções e casos de teste para essas funções. A tarefa mais frequente após a compilação e construção é executar casos de teste. Vamos ver como é feito.

Crie um novo repositório GitHub e adicione um src/lib.rs arquivo abaixo. Como você pode ver, ele define uma função Rust e alguns casos de teste. Ele pode ser construído e lançado como um pacote de biblioteca Rust.

pub fn say(s: &str) -> String {
  let r = String::from("hello ");
  return r + s;
}

#[cfg(test)]
mod tests {
  use super::*;
  
  #[test]
  fn say_hello() {
    let result = say("ssvm");
    assert!(result.contains("hello ssvm"));
  }
}
O arquivo src / lib.rs

Então, volte para a raiz / diretório do repositório GitHub e adicione o seguinte Cargo.toml Arquivo.

[package]
name = "hello"
version = "0.1.0"
authors = ["ubuntu"]
edition = "2018"

[lib]
name = "hello_lib"
path = "src/lib.rs"
crate-type =["cdylib"]

[dependencies]

Clique na guia Ações e adicione o fluxo de trabalho Rust padrão. Como você se lembra, o fluxo de trabalho Rust padrão termina com cargo test, que é exatamente o que precisamos aqui.

As ações padrão do fluxo de trabalho Rust são o que precisamos aqui.

O fluxo de trabalho é executado sempre que um novo código é enviado para este repositório. Você pode clicar em abrir uma construção bem-sucedida e ver a saída das ações de construção e teste.

As ações do Github criam e testam seu programa Rust

Qual é o próximo

Agora você pode experimentar seu código Rust e solicitar ao GitHub que construa, teste e execute para você com saídas completas do console, de graça e sem sair do navegador!

Recursos

Sobre o autor

Dr. Michael Yuan é o autor de 5 livros em engenharia de software. Seu último livro Criando aplicativos Blockchain foi publicado por Addison-Wesley em dezembro de 2019. Você pode começar com seu primeiro aplicativo da web descentralizado em 5 minutos usando o BUIDL IDE online (com tutoriais do livro)

Ele também é o CEO da Segundo Estado, uma empresa que se concentra em trazer as tecnologias WebAssembly e Rust para aplicativos em nuvem, blockchain e IA.

Antes do Segundo Estado, o Dr. Yuan colaborou por muito tempo em código aberto na Red Hat, JBoss e Mozilla.

Fora do software, o Dr. Yuan é um pesquisador principal nos Institutos Nacionais de Saúde, com vários prêmios de pesquisa em pesquisas sobre câncer e saúde pública. Ele é PhD em astrofísica pela Universidade do Texas em Austin.