Não muito tempo atrás, guardávamos nossos dados apenas nos computadores pessoais. Esses dados eram de todo tipo de arquivo, como fotos, documentos de texto, planilhas, e eram guardados no disco rígido, organizados na mais cuidadosa hierarquia do sistema de arquivos.

Uma hierarquia de diretórios, com os arquivos do diretório selecionado à direita.

Tudo muito bom, tudo muito bem, até precisarmos compartilhar um documento com algum colega. Então precisávamos comprar um pen drive disquete que poderíamos entregar a outra pessoa. O problema disso é que, não só o disquete não era um meio muito confiável, mas isso criava duas versões do mesmo arquivo. Quando recebíamos o arquivo de volta, tínhamos que ter certeza de que não havíamos modificado a versão original. Pior, se tivéssemos modificado, teríamos que comparar palavra por palavra.

Com a popularização da internet surgiu um alternativa: guardarmos o arquivo em um servidor centralizado e editarmos esse arquivo diretamente usando o navegador. São várias as opções disponíveis de gerenciadores de documentos e suítes de escritório online, Google Docs, Office Online, Dropbox, etc. Cada um com uma interface diferente.

Cada serviço é um produto diferente, com seu próprio desenho de interface.

Embora muito práticas e fáceis de usar, essas ferramentas trazem duas complicações importantes que não existiam antes.

1. Como não existe mais uma hierarquia de arquivos pessoais bem organizada, precisamos encontrar, entre as centenas ou milhares de arquivos existentes, aqueles que contêm uma ou mais palavras de busca. E devemos fazer isso muito rapidamente.

2. Como vários usuários podem editar um documento ao mesmo tempo, não podemos mais guardar um arquivo apenas quando terminamos de editá-lo. Ao invés disso, toda vez que fazemos qualquer edição em um arquivo, enviamos um comando ao servidor pela internet e aguardamos a resposta.

Nesta tarefa, você irá criar um novo gerenciador de documentos com o objetivo de desbancar as soluções existentes. O diferencial: seu gerenciador de documentos é voltado para programadores, então implementaremos apenas a interface de comandos — e cada programador pode criar a interface mais adequada para seus usuários! Você irá criar um programa chamado gerenciador.py que será capaz de executar uma série de comandos especificados neste enunciado.

Por enquanto, implementaremos apenas um protótipo com diversas simplificações. Uma delas é que nosso gerenciador de documentos não armazenará os arquivos de fato e guardará os dados apenas em memória. Além disso, ele permite apenas criar e editar arquivos de texto. Cada arquivo existente contém as seguintes propriedades:

• nome do arquivo;
• texto do conteúdo;
• nome de usuário que criou o arquivo;
• data da criação.

Lembre-se de que você deve definir uma representação em memória adequada para cada tipo de objeto abstraído. Para cada tipo, você deve armazenar e escolher as estruturas de dados que julgar necessárias ou convenientes para implementar os diferentes comandos de seu gerenciador.

Entrada

A entrada consiste de uma sequência de comandos, um por linha. Em cada momento, deve haver exatamente um usuário ativo e cada comando será executado por esse usuário. Assim, o primeiro comando será sempre entrar <nome>, para descrever o primeiro usuário ativo. A entrada termina quando for executado o comando terminar.

entrar laura
criar frutas.txt
digitar frutas.txt banana
digitar frutas.txt abacaxi pera
digitar frutas.txt jabuticaba banana
substituir frutas.txt abacaxi goiaba
entrar pedro
buscar banana
mostrar frutas.txt
terminar

Saída

Cada uma dos comandos produz uma saída de texto. Por exemplo, o comando mostrar exibe o conteúdo de um arquivo.

laura entrou!
frutas.txt criado
frutas.txt modificado: 1 linhas
frutas.txt modificado: 2 linhas
frutas.txt modificado: 3 linhas
frutas.txt modificado: 3 linhas
pedro entrou!
frutas.txt contém banana
1 arquivos encontrados
--- início de frutas.txt ---
banana
goiaba pera
jabuticaba banana
--- final de frutas.txt ---
até mais!

Comandos

O conjunto completo de comandos está listado abaixo.

• terminar

  Mostra a mensagem até mais! e encerra a execução do programa.

• entrar <usuário>

  Altera o usuário ativo e mostra a mensagem <usuário> entrou!.

• criar <arquivo>

  Cria um novo arquivo vazio com o nome fornecido se já não existir. A resposta deve ser arquivo <arquivo> criado ou arquivo <arquivo> existente.

• carregar <arquivo_local> <arquivo>

  Cria um novo arquivo com o conteúdo de um aquivo local armazenado no seu computador. Por exemplo: carregar dados/arquivo_local.txt novo_arquivo.txt. A resposta deve ser <arquivo_local> carregado como <arquivo>. Você pode supor que ainda não existe aquivo com o mesmo nome no gerenciador.

• digitar <arquivo> <linha de texto>

  Acrescenta uma linha de texto no final do arquivo e mostra mensagem <arquivo> modificado: <numero> linhas com o número de linhas do arquivo.

• mostrar <arquivo>

  Mostra todo o conteúdo do arquivo entre linhas demarcadoras:

  --- início de frutas.txt ---
  ... conteúdo ...
  --- final de frutas.txt ---
  

• substituir <arquivo> <termo> <substituto>

  Substitui todas as ocorrências do termo no arquivo e mostra mensagem <arquivo> modificado: <numero> linhas com o número de linhas do arquivo.

• listar ou listar -t

  Mostra a lista de arquivos existentes. Para cada arquivo, é mostrada uma linha com <arquivo> <usuário>. Por padrão, os arquivos são listados em ordem alfabética. Caso seja passado o argumento opcional -t, então os arquivos são listados em ordem de criação.

  Ao final, mostra a mensagem <numero> arquivos existentes, onde <numero> é a quantidade de arquivos que há no gerenciador.

• buscar <termo>

  Lista os arquivos que contêm o termo buscado, um por linha e em ordem alfabética. Para cada arquivo encontrado, o comando mostra uma linha com a mensagem <arquivo> contém <termo>.

  Ao final, o comando mostra <numero> arquivos encontrados, onde <numero> é a quantidade de arquivos que contêm o termo procurado.

• comparar <arquivo1> <arquivo2>

  Mostra diferença entre dois arquivos, linha por linha, em um formato similar à saída do comando diff do Unix. Você pode supor que os dois arquivos têm o mesmo número de linhas e todas as linhas diferentes são adjacentes. Veja o exemplo:

  a.txt

  Já vai embora?
  Viver é que nem
  andar de bicicleta.
  Se parar, cai.
  

  b.txt

  Já vai embora?
  Programar é que nem
  andar na corda bamba.
  Se parar, cai.
  

  saída do diff

  < Viver é que nem
  < andar de bicicleta.
  ---
  > Programar é que nem
  > andar na corda bamba.
  

Simplificações

Nas substituições e buscas de palavras, serão consideradas apenas palavras completas. Por exemplo, os resultados de uma busca por ama não incluem amargo, grama. Você pode supor que não existem palavas com caracteres de pontuações adjacentes, como ama,. Além disso, as operações são case-sensitive, isto é, são consideradas diferentes as palavras ama e Ama.

Critérios

Nesta tarefa você deverá usar apenas as estruturas de dados fornecidas por padrão na linguagem Python.

Correção

Esta tarefa será corrigida automaticamente sempre que você realizar um git push. Depois de submetida a versão final da tarefa, você deverá apresentá-la a um monitor PED. Para isso, você deve procurar atendimento em algum horário com monitor PED e digitar apresentar 8 no canal fila-apresentar para entrar na fila.

← Anterior Voltar Próximo →