Re: [shell-script] Construção de CASE Complexa

[Rodrigo Amorim Ferreira | CODECOMMUNITY]

Oi Tiago,

Muito interessante sua abordagem ao problema.

Acredito então que, com essa lógica proposta por você, ficaria mais
fácil de ampliar o programa, mantendo sua modularidade e possibilidade
de expansão, para um número crescente de opções na linha de comando? Se
sim, vou pensar em algo com essa base de raciocínio, pois o meu projeto
prevê muitos níveis de opções de entrada na linha de comando.

Atualmente a linha de comando produziria de $0 (o próprio nome do
programa) até $6, em formato de árvore (i. é: as opções iniciais seriam
quase sempre as mesmas, com um número menor de exceções). Mas dependendo
dos refinamentos futuros de opções, poderá crescer ainda mais (mas
acredito não passar de $8 ou $9).

Alguns exemplos:

Para reconstruir um arquivo dentro de um subprojeto:

  <script> -p, --project PROJECT -s, --subproject SUBPROJECT -f FILE -r,
--rebuild

Para reconstruir um subprojeto inteiro (todos os arquivos de um
subprojeto, com confirmação):

  <script> -p, --project PROJECT -s, --subproject SUBPROJECT, -R,
--Rebuild

Para reconstruir um projeto inteiro (todos os subprojetos com todos os
seus arquivos, com confirmação):

  <script> -p, --project PROJECT, -RR, --REBUILD

Mas existem as opções iniciais diferentes. São em menor número mas de
igual importância. Seguem alguns exemplos:

Cria um novo projeto (e um subprojeto):

  <script> -P, --Project PROJECT -S, --Subproject SUBPROJECT

Cria um novo projeto (e, de forma automática, um subprojeto www):

  <script> -P, --Project PROJECT

Cria um subprojeto dentro de um projeto existente:

  <script> -p, --project PROJECT -S, --Subproject SUBPROJECT

para você ter uma ideia de como eu estou pensando em construir o
programa.

Ainda existe muito mais linhas de comando como essa já pensadas e
registradas para futura implementação, sendo os exemplos acima uma
pequena amostragem para ajudar a entender melhor o que eu estou tentando
construir.

Agradeço a ajuda.

Um abraço.

Rodrigo

On Sat, 2016-07-09 at 11:04 +0200, Tiago Peczenyj
address@hidden [shell-script] wrote:
>   
> EU gosto de separar a logica de compreender as opções (-x --y ) da
> logica que avalia se elas fazem sentido (opções com valores invalidos,
> duplicados, etc, e da logica, por fim, que interpreta os mesmos.
> 
> 
> 
> Dito isso eu transformaria o switch/case em algo que habilita
> variaveis/flags.
> 
> 
> Depois eu iria validar fora do loop.
> 
> 
> Depois eu iria utilizar.
> 
> 
> Faço isso pois o script pode evoluir (se tem muita opção, pode ter
> mais) e para ser facil de testar. E é facil de extrair para um script
> q servira de base para outros ou incluido via source.
> 
> 
> A menos q seja algo trivial como 2 ou 3 opções.
> 
> 
> Por fim, invista em uma opcao de help/usage decente. E se vc tem
> comportamentos default, descreva-os.
> 
> Em sábado, 9 de julho de 2016, address@hidden [shell-script]
> <address@hidden> escreveu:
>           
>         Oi Pessoal,
>         
>         Boa madrugada! Antes de mais nada, peço desculpas antecipadas
>         caso a lista receba mais de uma mensagem minha sobre o mesmo
>         tema, pois me parece que não está funcionando o envio de
>         mensagens diretamente de minha conta de email e estou
>         re-enviando essa cópia através do painel de controle do Yahoo
>         Groups. Alguém saberia de algum problema, ou bloqueio?
>         
>         
>         DÚVIDA SOBRE CONDICIONAL DO TIPO CASE
>         
>         
>         Gostaria de tirar uma dúvida: é possível criar um tipo
>         condicional case
>         com opções AND e OR misturadas em cada opção de padrão a ser
>         analisado?
>         
>         Exemplos: eu sei que e possível criar um tipo condicional case
>         básico
>         como:
>         
>         case $1 in
>           -p)
>             echo "Opção 1"
>             ;;
>           -s)
>             echo "Opção 2"
>             ;;
>           -f)
>             echo "Opção 3"
>             ;;
>            *)
>             echo "Modo de uso: nome_do_programa {-spf}"
>         esac
>         
>         Neste caso ele analisa o uso do executável com apenas uma
>         opção:
>         
>           $ nome_do_programa -p
>           Opção 1
>           $ nome_do_programa -s
>           Opção 2
>           $ nome_do_programa -f
>           Opção 3
>         
>         Eu sei que é possível expandir o uso das opções, de cada
>         padrão a ser
>         analisado, com o OR:
>         
>         case $1 in
>           -p|--project)
>             echo "Opção 1"
>             ;;
>           -s|--subproject)
>             echo "Opção 2"
>             ;;
>           -f|--file)
>             echo "Opção 3"
>             ;;
>            *)
>             echo "Modo de uso: nome_do_programa {-spf}"
>         esac
>         
>         O que permite ele funcionar para os seguintes casos:
>         
>           $ nome_do_programa -p
>           Opção 1
>           $ nome_do_programa --project
>           Opção 1
>           $ nome_do_programa -s
>           Opção 2
>           $ nome_do_programa --subproject
>           Opção 2
>           $ nome_do_programa -f
>           Opção 3
>           $ nome_do_programa --file
>           Opção 3
>         
>         E também sei que é possível utilizar AND para evitar (ao
>         máximo) o uso
>         de condicionais do tipo case aninhadas, como:
>         
>         case $1:$2:$3 in
>           -p:-s:-f)
>             echo "Opção 1, 2 e 3 simultâneas"
>             ;;
>            *)
>             echo "Modo de uso: nome_do_programa {-s -p -f}"
>         esac
>         
>         que responderia da seguinte maneira:
>         
>           $ nome_do_programa -p -s -f
>           Opção 1, 2 e 3 simultâneas
>         
>         Mas não descobri como fazer (se é realmente possível) o uso do
>         AND e do
>         OR simultâneo em cada opção de padrão a ser analisado pelo
>         tipo
>         condicional case. É possível criar uma opção de padrão que
>         misture
>         ambas? Algo como (eu sei que não funciona):
>         
>         -p|--project:-s|--subproject:-f|--file)
>         
>         que permitisse gerar resultados como:
>         
>           $ nome_do_programa -p -s -f
>           Opção 1, 2 e 3 simultâneas
>           $ nome_do_programa --project -s -f
>           Opção 1, 2 e 3 simultâneas
>           $ nome_do_programa -p --subproject -f
>           Opção 1, 2 e 3 simultâneas
>           $ nome_do_programa -p -s -file
>           Opção 1, 2 e 3 simultâneas
>           $ nome_do_programa --project --subproject -f
>           Opção 1, 2 e 3 simultâneas
>           $ nome_do_programa --project -s --file
>           Opção 1, 2 e 3 simultâneas
>           $ nome_do_programa -p --subproject --file
>           Opção 1, 2 e 3 simultâneas
>           $ nome_do_programa --project --subproject --file
>           Opção 1, 2 e 3 simultâneas
>         
>         Estou tentando ao máximo obter opções de construção de
>         programas em
>         shell com o uso do tipo condicional case para não precisar
>         utilizar
>         (muito) a sua forma aninhada e tentar manter o código o mais
>         "simples"
>         possível.
>         
>         Também acredito que posso estar redondamente enganado, e essa
>         linha de
>         raciocínio pode vir a complicar meu projeto mais à frente. Por
>         isso
>         qualquer solução alternativa que mude minha linha de
>         desenvolvimento e
>         torne o programa melhor (e mais legível) também é muito bem
>         vinda.
>         
>         Desde já agradeço a ajuda.
>         
>         Saudações.
>         
>         Rodrigo Amorim
>         
>         
>         
>         
> 
> 
> -- 
> Tiago B. Peczenyj
> 
> http://about.me/peczenyj
> 
> 
> 
> 
>