Artigo: Como fazer shell script profissional [RESOLVIDO]

davidsonpaulo
(usa Ubuntu)

Enviado em 21/09/2011 - 11:34h

Administrador Linux que se preze tem que saber fazer um bom shell script, que consiga resolver desde as necessidades mais simples até as mais complexas, usando poucas ou muitas linhas de código.

Se você ainda não é um ninja na arte de escrever shell script, está na hora de começar a aprender. Vamos lá!

http://blog.davidsonpaulo.com/2011/09/como-fazer-shell-script-profissional.html

danniel-lara
(usa Fedora)

Enviado em 21/09/2011 - 11:40h

Legal mesmo

alexandregms
(usa Ubuntu)

Enviado em 21/09/2011 - 16:46h

Show!!
Depois que comecei a criar meus scripts fui analisando que grande parte deles não possuía uma validação, do qual fizesse um tratamento de erro válido para cada execução de comando.
Por exemplo, se hoje eu vou fazer um script para mover o diretório /usr/system para /opt/bkp_system eu faria o seguinte:

if [ -d /usr/system ]; then



    if [ -d /opt/bkp_system ]; then



        mv /usr/system /opt/bkp_system



        if [ $? -eq 0 ]; then



            echo "Pasta /usr/system movida para /opt/bkp_system"

            exit 0



        else



            echo "Problemas ao mover /usr/system para /opt/bkp_system"

            exit 1



        fi



    else



            echo "Pasta /opt/bkp_system não econtrada"

            exit 1



    fi



else



    echo "Pasta /usr/system não encontrada"

    exit 1



fi

 

É cansativo escrever um código deste? SIM! Mas é a forma mais correta? SIM!
Com o passar dos anos comecei a utilizar todos os tratamentos de erros possíveis para que os meus códigos sempre executassem corretamente. Também procuro gerar logs a afim de validar se tais execuções foram realizadas ou não.

Hoje uso bastante os "exit" ou "return" para que as saídas possam ser debugadas de forma mais rápida!

Realmente como o Davidon falou, existem muitos scripts sem identações, do qual prejudica um futuro ajuste no código! Comentários nos scripts também não podem deixar de existir!

Ótimo artigo, parabens!

alexandregms
(usa Ubuntu)

Enviado em 21/09/2011 - 16:47h

Detalhe: esta página WEB não permite iniciar o parágrafo com espaços, por isso o código acima não foi com a identação correta ;-)

hudyfx
(usa Outra)

Enviado em 21/09/2011 - 17:56h

ok! para os novatos e os "Marmanjos" do shell comentário e cabeçalho é extremamente essencial sim! mas uma boa e bela indentação de um codgo as vezes fala por si só... num ambiente corporativo vc não espera que um novato vai dar manutenção em scripts de missão critica, primeiro porque é "critico" segundo, porque é complexo...
vc não vai escreve num comentário como esse : "A variavel 'var' foi usada com '${#' para obter o numero de caracteres em sua matriz" como se vc estivesse dando um curso dentro do script rsrsrs

sei que os iniciantes em shell necessitam arduamente de comentários plausíveis...
mas um comentário pode ser plausível, curto e muito bem intendido se vier acompanhado de uma bela indentação.
exemplo:

#!/bin/bash

# verifica.sh

# verifica quantas vezes determinada palavra ou frase aparece dentro de outra 

# frase ou palavra...

# versão 0.0.0

# autor: hudyfx

# dediaco a: dedicado a comunidade vol pq alguem pediu mas nao lembro que... rsrs



# Recebe duas entras A e B

clear 

echo -ne "digite a palavra A # "

read A

clear 

echo "palavara \"A\" = $A"

echo -ne "digite a palavra B # "

read B

clear 

# Verifica se entrada A é maior que B

if [ ${#A} -gt ${#B} ]; then

        echo " Impossivel Palavra A estar comtida em B pois A eh maior que B"

else

cont=0

# faz uma animação e conta os dados obtidos

        for ((i=0; i<=$((${#B} - ${#A}));i++)); do

                echo "palavra \"A\" = $A"

                echo "palavra \"B\" = $B"

                echo "Rastreando a lavra"

                echo -e "${B:0:$i}\e[31m${B:$i:${#A}}\e[0m${B:$((i + ${#A})):${#B}}"

                echo ${B:$i:${#A}}

                if [ "${B:$i:${#A}}" = "$A" ]; then 

                        cont=$(($cont + 1))

                fi

                sleep .1

                clear

        done

fi

# improme a saída desejada

echo " A palavra $A esta contida $cont vezes em $B"

 

ta certo... um cara que ta começando muitas vezes não sabe oque isso ${B:$i:${#A}} faz
mas comentar uma linha assim seria desnecessário pois isso faz parte da linguagem e não do codigo...


isso é só minha opinião rsrsrs
mas a ideias da explicação é indiscutível! rsrs

falowww

natanaelhenrique
(usa Arch Linux)

Enviado em 22/09/2011 - 16:21h

Já temos no fórum as tags [ code ] seu script [ / code ] (sem os espaços, é claro) que permitem tal identação e inclusive com highlight, veja como ficou seu exemplo. Você também pode usar as tags quando for postar algum resultado de comando que tenha espaços ou tabulações como o df -h, por exemplo.

removido
(usa Nenhuma)

Enviado em 22/09/2011 - 17:27h

Recomendo a todos, para evitar grande desfiguração na identação que configurem seus editores para que quebrem as linhas na coluna 80 e que suas tabulações estejam configuradas para 4 espaços. Isso é um padrão "inter editores" que visa que o código seja visto da mesma maneira em qualquer editor ou tela - ou pelo menos na maioria deles .

Vejam esta versão da contribuição anterior.

#!/bin/bash



declare -r ORIGEM='/usr/system'

declare -r BCK='/opt/bkp_system'



if [ -d "$ORIGEM" ]

then

	if [ -d "$BCK" ]

	then

		mv "$ORIGEM" "$BCK"



		if [ $? -eq 0 ]

		then

			echo "Pasta $ORIGEM movida para $BCK"

			exit 0



		else

			echo "Problemas ao mover $ORIGEM para $BCK"

			exit 1



		fi



	else

		echo "Pasta $BCK não econtrada"

		exit 1



	fi



else

	echo "Pasta $ORIGEM não encontrada"

	exit 1



fi

 

alexandregms
(usa Ubuntu)

Enviado em 22/09/2011 - 17:33h

Valeu n4t4n!
Não conhecia essa tag, será muito usada agora!!!

removido
(usa Nenhuma)

Enviado em 22/09/2011 - 17:50h

Veja esta outra versão do mesmo código usando procediemntos. Note como ela não carece tanto de comentários, porque os nomes dados aos procedimentos são relativamente intuitivos. Porém, perceba que aproveitei na integra a lógica usada anteriormente pelo colega acima.

#!/bin/bash

# Efetua backup da pasta /usr/system para /opt/bck_system'



ORIGEM='/usr/system'

BCK='/opt/bkp_system'



function _foiMovida()

{

	echo "Pasta $ORIGEM movida para $BCK"

	return 0

}



function _naoMovida()

{

	echo "Problemas ao mover $ORIGEM para $BCK"

	return 1

}



function _bckDirInexiste()

{

	echo "Pasta $BCK não econtrada"

	exit 1

}



function _origemDirInexiste()

{

	echo "Pasta $ORIGEM não encontrada"

	exit 1

}



function _efetuaBck

{

	mv "$ORIGEM" "$BCK"

}





if [ -d "$ORIGEM" ]

then

	if [ -d "$BCK" ]

	then

		_efetuaBck



		if [ $? -eq 0 ]

		then

			_foiMovida



		else

			_naoMovida



		fi



	else

		_bckDirInexiste

	fi



else

	_origemDirInexiste



fi

 

Mas esse é um pouco do meu meu estilo e portanto apenas uma sugestão que compartilho com a comunidade.
:D

removido
(usa Nenhuma)

Enviado em 22/09/2011 - 19:52h

#!/bin/bash

# package:  Helps do Vol

#

# file: bckEgVol.sh

# Efetua backup da pasta /usr/system para /opt/bck_system.

# Nota: Apenas uma demonstração melhorada do estilo do autor do script com base no problema proposto neste mesmo post e portanto não passa de uma sugestão para melhorar a leitura imediata de código. Boa Sorte!

#

# since:    2010-07-30 23:58:00 (GMT -03:00)

# version:  1.0

# autor:    Paulo Riceli Dias Lelis

#

# charset:  UTF-8

# end line: Linux

# license:  GPL v2.0

# more: http://sekysu.blogspot.com

#

# System:   Linux Slackware 12.2 Kernel 2.6.27.7-smp



declare -r _ORIGEM='/usr/system'

declare -r _BCK='/opt/bkp_system'



declare -r _MSG_0="SUCESSO: Pasta ${_ORIGEM} copiada para ${_BCK}"

declare -r _MSG_1="ERRO: Problemas ao mover ${_ORIGEM} para ${_BCK}"

declare -r _MSG_2="ERRO: Pasta ${_BCK} não econtrada"

declare -r _MSG_3="ERRO: Pasta ${_ORIGEM} não encontrada"



function _sucesso()

{

   echo "${_MSG_0}"

   return 0

}



function _semSucesso()

{

   echo "${_MSG_1}"

   return 2

}



function _destinoInexistente()

{

   echo "${_MSG_2}"

   exit 1

}



function _origemInexistente()

{

   echo "${_MSG_3}"

   exit 1

}



function _efetueBackup

{

	cp -v "${_ORIGEM}" "${_BCK}" &&

	_sucesso ||

	_semSucesso

}





if [ -d "${_ORIGEM}" ]

then

   if [ -d "${_BCK}" ]

   then

      _efetueBackup



   else

      _destinoInexistente



   fi



else

   _origemInexistente



fi

 

saitam
(usa Slackware)

Enviado em 22/09/2011 - 20:11h

#!/bin/bash

#script de backup



mount /dev/sda1 /mnt/sda1

montado=`mount | grep /mnt/sda1`



if [ -z "$montado" ]; then

    exit 1

    else

      DATA=`date +%Y-%m-%d-%H.%M`

      cd /mnt/backup

      tar -zcvf trabalho-"$DATA".tar.gz $HOME

      umount /mnt/sda1

    fi

 

AprendiNoLinux
(usa Ubuntu)

Enviado em 22/09/2011 - 23:32h

Iniciei meu aprendizado mesmo em Shell Script tem na verdade uns 90 dias. Antes era tudo na orelhada mesmo.
Meus primeiros contatos aqui no fórum de cara se mostraram que o caminho estava errado e fui muito bem orientado.
Segue algumas construções que fiz e estou batendo cabeça para fazer rsrs.



Praticamente estou refazendo todos os códigos novamente porque a linha de trabalho não estava boa. Após toques do Prof. Raimundo, Ronim, Udson, Alexandre, fui revendo a realidade que não é a dos livros.



Funciona 100% o código que está colorizado.
A versão 2.0 que será baseada na 1.0 será em modo gráfico. Tem um outro colaborador do VOL que está me dando uns toques.



O que não estou mudando é a forma de documentar, analisar, preparar a construção dos Scripts.
Procurei documentar a minha forma de pensar aqui: http://www.vivaolinux.com.br/topico/Shell-Script/Sugestoes-para-convencoes-na-programacao-de-SHELL-S...
Com a colaboração de poucos participantes, algumas dúvidas foram sanadas e a vivência está me fazendo remodelar e evoluir.
De qualquer modo, pretendo no futuro criar alguns artigos sobre a minha experiência no desenvolvimento de Shell Script e suas convenções.
Sinto que estou começando a dominar o trem rsrs.

Muito por fazer e aprender...

A lição eu já sei. Pesquise, pesquise, pergunte, pergunte, compartilhe, compartilhe, ajude, ajude.

#!/bin/bash

# file: cardapio.sh

# author: Geraldo T. Albuquerque aka @GA_Tux ou @AprendinoLinux

# co-author: Hudson Moreira Guimaraes dos Santos aka @hudyfx

# version: 1.0 beta

# objetives: Script coleta a digitação de códigos de uma lanchonete.

# detalhes: Lembrei do Roberto Carlos rss. São tantas emoções....

# ----------------------------------------------------------------------------

# Desenvolva um programa em shell que leia o código do item pedido,

# a quantidade e calcule o valor a ser pago por aquele lanche.

# Considere que a cada execução somente será calculado um item.

# ----------------------------------------------------------------------------

# Roadmap e changelog:

# 1 - Criar uma lista com os produtos e seus preços. (ok)

# 2 - Carregar a lista de preço via arquivo (ok) grato ao @hudyfx

# 3 - Permitir escolher o produto na lista. (ok) grato ao @hudyfx

# 4 - Mostrar o sub-total que está dando a conta. (ok)

# 5 - Mostrar os itens escolhidos no pedido. (ok)

# 6 - Finalizar a comanda. (ok)

# 7 - Salvar o pedido temporário ok (está em memória)

# 8 - Salvar o pedido finalizado ? #FIXME Falta aprender aproveitar a tela.

# 9 - Montar ticket do pedido. (ok) Créditos ao @hudyfx

# 10- Configuração para usar vários arquivos de cardápio. (ok)

# ----------------------------------------------------------------------------

# XXX: Formatar a saída está uma dificuldade, alinhar a direita.

# XXX: Duas POGs foram criadas para quebrar o galho, mas não está legal.

# TODO: Falta criar um cabeçalho com os nomes de campos no arquivo cardapio.txt

# ----------------------------------------------------------------------------



# Variáveis globais

# ----------------------------------------------------------------------------

start=0     # Controla o início das digitações.

valor_pedido=0  # Acumula o valor do pedido em aberto.

tab_precos= # Armazenar a tabela completa com preços , códigos e nomes.

_itens_pedido=  # Coleta os itens digitados no pedido.

cont_iped="0"   # Contador de itens no pedido.

# ----------------------------------------------------------------------------



# Configs para o arquivo de cardápio.

# ----------------------------------------------------------------------------

_CONF_CARDAPIO="cardapio.txt"

_DIR_CARDAPIO="${PWD}"

_FILE_CARDAPIO="${_DIR_CARDAPIO}/${_CONF_CARDAPIO}"

# ----------------------------------------------------------------------------



# Reconfigura as variáveis globais após fechar e finalizar o pedido.

function inicializa()

{

    valor_pedido="0"

    cont_iped="0"

    _itens_pedido=

    start=0

}



# Executa rotina de impressão e finalização do pedido. Cobra até imposto rsrs.

# Não cobra o imposto, mas poderia cobrar. Fica como desafio para alguém.

function finaliza()

{

    if [ "$valor_pedido" -gt 0 ]

    then

        # Neste ponto pode ser adicionado gravação ou impressão do pedido.

        ped_numero=$(date +"%s")

        clear

        echo "+=========================================+"

        echo "|Finalizando o Pedido nº.....: ${ped_numero} |"

        echo "+=========================================+"

        echo "|Deseja nota fiscal paulista ? kkkkk      |"

        echo "+---+-------------------------------+-----+"

        echo "|Cod| Produto                       |Preço|"

        echo "+---+-------------------------------+------"

        itens_do_pedido

        echo "+---+-------------------------------+------"

        echo " Total da fatura....................: ${valor_pedido}"

        echo "+=========================================+"

        echo "|Impostos a pagar: Iss, icms, pis, cofins |"

        echo "+=========================================+"

        read -t 10

        inicializa

        return

    else

        echo ""

        echo "================================================="

        echo "Você não digitou nenhum pedido ainda."

        echo "Está com pressa ? rsrs "

        echo "================================================="

        read -t 5

    fi



}



# Se o seek na tabela de memória falhar, vai alertar o usuário.

function naoexiste()

{

    echo ""

    echo "Produto $numero não existe, confira o cardápio !!! "

    read -t 5

}



# Responsável por armazenar os itens no arquivo de memória dos pedidos.

# Note que se desejar armazenar em disco, é muito fácil nesta estrutura.

function digitei()

{

# Agora validando o código do produto com base no arquivo de tabela de preços.

# Apreoveita a tabela que já está em memória. (Desafio pessoal)

# Usar uma tabela armazenada em disco é fácil, difícil é controlar em memória.

for meuvalor in ${tab_precos[@]}

do

    meu_cod=$(echo ${tab_precos[$numero]} | cut -d: -f1)

    meu_nome_prod=$(echo ${tab_precos[$numero]} | cut -d: -f2)

    meu_preco=$(echo ${tab_precos[$numero]} | cut -d: -f3)

    if [ "$meu_cod" = "$numero" ]

    then

        valor_pedido=$((valor_pedido + meu_preco))



        #Salvando os itens do pedido.

        cont_iped=$((cont_iped +1))



        # Que POG lascada, mas não conheço outra forma de fazer.

        SEPA1="|"

        SEPA2=" |"

        if [ ${#meu_preco} -eq 4 ]

        then

            posit=${SEPA1}

        else

            posit=${SEPA2}

        fi

        _itens_pedido["$cont_iped"]="|${meu_cod}| ${meu_nome_prod}| ${meu_preco}${posit}"



        # Salva o novo valor digitado. Não importa se é repetido ou não.

        digitando["$contador"]="$1"



        # Faz incremento do contador para o próximo passo.

        let contador++



        return

    fi

done

naoexiste ; return

}



# Mostra os códigos já digitados e o valor acumulado do pedido.

function digitado()

{

    if [ $start = "0" ]

    then

        start="1"

        return

    fi

    echo "Produtos digitados.: ${digitando[@]} "

    echo "Sub-Total é........: ${valor_pedido} "

}



# Área principal da digitação. Deste local pode-se ir a qualquer lugar.

function digitar()

{

    while true

    do

        clear

        mostramenu

        digitado

        echo ""

        echo -n "Digite o código do produto...:"

        read numero

        if test $numero -gt 0

        then

            digitei $numero

            digitado

        else

            _opcoes "$numero"

            mostramenu

        fi 2> /dev/null

    done

}



# Fica como desafio para alguém que queira praticar.

# XXX: Falta dominar o processo de salvar usando as linhas de echo + tela.

function salva_pedido()

{

: # Caso precise salvar o pedido finalizado.

}



# XXX: Tenho dificulade em salvar o pedido linha a linha usando as telas.

function salva_tmp()

{

: # Caso precise salvar o pedido temporário.

}



# Prepara a chamada para listar o andamento do pedido.

function listar()

{

    if [ "$valor_pedido" -gt 0 ]

    then

        listar_pedido

    else

        echo ""

        echo "================================================="

        echo "Você não digitou nenhum pedido ainda."

        echo "Está com pressa ? rsrs "

        echo "================================================="

        read -t 5

    fi

}



# Efetiva a listagem do pedido neste momento.

function listar_pedido()

{

    clear

    echo "+=========================================+"

    echo "|Pedido digitado                          |"

    echo "+=========================================+"

    echo ""

    echo "+---+-------------------------------+-----+"

    echo "|Cod| Produto                       |Preço|"

    echo "+---+-------------------------------+------"

    itens_do_pedido

    echo "+---+-------------------------------+------"

    echo " Sub-total do pedido................: ${valor_pedido}"

    echo "+=========================================+"

    echo -n " ENTER retorna ao pedido."

    read

    return

}



# Contém os produtos digitados e já formatado para o padrão da saída.

# TODO: Valores quando formam gravados não estão alinhados a direita.

# TODO: Aqui a recuperação é apenas a leitura do array em memória.

function itens_do_pedido()

{

local i

i="1"

while true

do

    if [ "${#_itens_pedido[$i]}" -gt 0 ]

    then

        echo "${_itens_pedido[$i]} "

    else

        # Acabou o pedido, posso sair.

        return

    fi

    let i++

done

return

}



# Dá de pinote do sistema. Agora com mais équio.

# FIXME: Se tem pedido em aberto, não avisa o usuário.

# FIXME: Próxima versão precisa fazer esta verificação.

function sair()

{

    echo ""

    echo "+---------------------------------------------------------+"

    echo "|Finalizando o sistema bye. Digitação não foi gravada !!! |"

    echo "|É importante verificar se não existe um pedido em aberto.|"

    echo "|Fica como pendência a ser resolvida                      |"

    echo "+---------------------------------------------------------+"

    read -t 0.5

    exit

}



# Quase todos os erros levam a esta tela genérica.

function erro()

{

    echo ""

    echo "+------------------------------------------------------+"

    echo "|Opção digitada é inválida                             |"

    echo "|Precisa de ajuda ? use o help                         |"

    echo "+------------------------------------------------------+"

    read -t 2

}



# XXX: Uma tremenda POG para fazer a manobra no posicionamento.

# XXX: Não encontrei uma forma melhor para posicionar os produtos e valores.

# XXX: Se alguém quiser colaborar com algum regex ou uma nova forma, avise.

function completa_texto()

{

#------------------------------------------------------------------------------

# Recebe o Tamanho total = tt (numérico)

# Recebe a String a ser tratada = ts

# Calcula o Tamanho a completar = (tt -ts)

# Exemplo: Se um texto é "cachorro quente" ele tem 15 de tamanho preenchido.

#          Se o tamanho do campo é de 30, vou completar com 15 ???.

#------------------------------------------------------------------------------

    if [ "$1" = "-h" ]; then

        # Solicitando Ajuda para usar a função.

        clear

        echo "+------------------------------------------------------+"

        echo "|Ajuda para usar a função completa_texto               |"

        echo "+------------------------------------------------------+"

        echo "|Uso: completa_texto 20 'seu texto' '.' 'D'            |"

        echo "+------------------------------------------------------+"

        echo "|Útil quando você pega 1 campo do banco de dados.      |"

        echo "|Formatar a linha com um determinado tamanho desejado. |"

        echo "|Se você conhece algum regex para completar, me avise. |"

        echo "|Você pode completar com qualquer caracter - o espaço. |"

        echo "+------------------------------------------------------+"

        echo "|Exemplos: Seu campo de texto para usar no Script é de |"

        echo "|20 caracteres. No banco esta com 17 apenas.           |"

        echo "|Meu texto exemplo. Quando completar ficará:           |"

        echo "|Meu texto exemplo...                                  |"

        echo "+------------------------------------------------------+"

        echo "|A informação do banco vem com 25 caracteres.          |"

        echo "|Meu texto é muito grande.                             |"

        echo "|Ficará assim: Meu texto é muito...                    |"

        echo "+------------------------------------------------------+"

        read -t 10

        exit

    fi

    # Valida o recebimento de parâmetros de forma controlada.

    if [ "$#" -gt 2 ]

    then

        # Variáveis de trabalho.

        _tt="$1"        # Tamanho que o texto deverá retornar.

        _var_tmp="$2"       # Texto recebido

        _completar="$3"     # caracter que será usado no completar.



        # Avalia se o 1º parâmetro é um número.

        if [ $((_tt)) -gt 0 ]

        then

            # Confere se realmente enviou apenas 1 caracter.

            # Se enviou mais de 1 caracter, não sabe o que faz.

            if [ "${#_completar}" -gt 1 ]

            then

                echo "Só pode receber 1 caracter para completar"

                echo "Veja o que você está fazendo com: $3"

                sleep 5

                return 1 # Erro grave.

            fi



            # Forçando a verificação do tamanho recebido.

            # Se ele for >= ao total, será cortada.

            if [ "${#_var_tmp}" -ge "${_tt}" ]

            then

                _var_tmp=${_var_tmp:0:_tt-3}

            fi



            # Executando o complemento do texto solicitado.

            _vl_texto=${#_var_tmp}

            _falta=$((_tt - _vl_texto))

            i="1"

            _tmp_texto=$_completar



            while test $i -lt $_falta

            do

                let i++

                _tmp_texto="${_tmp_texto}${_completar}"

            done



            # Efetua o preenchimento a direita ou esquerda.

            # Parâmetro é opcional. Default é completar a direita.

            if [ "$4" = "E" ]

            then

                _texto_completo="${_tmp_texto}${_var_tmp}"

            else

                _texto_completo="${_var_tmp}${_tmp_texto}"

            fi

            echo "${_texto_completo}"

        else

            clear

            echo "+-------------------------------------------+"

            echo "| Este parâmetro tem que ser numérico: $_tt * "

            echo "| Verifique o que você está errado.         |"

            echo "| Texto será retornado sem alterações       |"

            echo "| Por este motivo, se vira nos 30 zé.       |"

            echo "+-------------------------------------------+"

            echo "$_var_tmp"

            read -t 5

            return 1 # Retornando erro pro zé.

        fi

    else

        clear

        echo "+------------------------------------------------------+"

        echo "|Não enviou a quantidade de parâmetros correta !!!     |"

        echo "+------------------------------------------------------+"

        echo "|1º) Numérico. Indica o tamanho que o texto ficará     |"

        echo "|2º) String do texto ou valor do texto a completar.    |"

        echo "|3º) Qual o caracter que será usado para completar.    |"

        echo "|4º) Completa Char. 'D'ireita ou 'E'squerda,opcional.  |"

        echo "+------------------------------------------------------+"

        echo "|Operação não será efetuada até acerto dos parâmetros. |"

        echo "+------------------------------------------------------+"

        read -t 5

        return 1 # Indica que houve um erro fatal.

    fi

}







# Tabela de preços. Usada para consulta e busca.

# Ficou até bacana a forma de gravar. Peca no posicionamento dos valores.

function tabela_de_precos()

{

# Pegar o arquivos cardapio.txt e trabalhar seus dados no formato.

# Tentar fazer ele ser aproveitado em rotinas posteriores.

while read linha;do

    # Monto um array para usar como tabela e indexador para seek.

    # Tratar valores de campo para compor a linha formatada.

    cod_prod=$(echo $linha | cut -d: -f2)

    pre_prod=$(echo $linha | cut -d: -f3)

    nom_prod=$(echo $linha | cut -d: -f1)

    nom_completo=$(completa_texto 30 "${nom_prod}" ".")

    # Armazenar só preços.

    tab_precos[${cod_prod}]="${cod_prod}:${nom_completo}:${pre_prod}"



    # FIXME: variável #POG para contornar tamanho de impressão.

    tp="6"



    # Só mostra na tela caso não seja chamado pelo processo de carga.

    if [ "$1" = "carga" ]

    then

    :

    else

        printf "%0s%-31s%-$((${#pre_prod} - ${tp}))s%-5s%-10s\n" \

        "|$cod_prod|" " $nom_completo" "|" "$pre_prod|"

    fi

done < "$_FILE_CARDAPIO" # Usa arquivo parametrizado.

}



# Tela genérica para o cardápio. Note que trabalha sempre em memória.

function cardapio()

{

    clear

    echo "+=========================================+"

    echo "|Cardápio lanchonete modelo Canabrava     |"

    echo "+=========================================+"

    echo ""

    echo "+---+-------------------------------+-----+"

    echo "|Cod| Produto                       |Preço|"

    echo "+---+-------------------------------+------"

        tabela_de_precos

    echo "+---+------------------------------.+-----+"

    echo -n "Enter retorna onde você estava          "

    read

}



# Sem novidade. Tela central do menu. É reaproveitado em vários locais.

function mostramenu()

{

    clear

    echo "========================================"

    echo "Menu Principal"

    echo "========================================"

    echo ""

    echo "c - Mostra Cardápio"

    echo "d - Digitar pedido"

    echo "l - Lista o pedido"

    echo "f - Finaliza o pedido"

    echo "s - Sair"

    echo "h - Ajuda"

    echo ""

    if [ "$1" ]; then echo -n "Escolha a opção:" ; fi



}



# Esta função não ajuda patavinas, rrs, mas serve de exemplo como fazer.

# Se for o caso, a aplicação pode montar parâmetros e tratar este local.

function ajuda()

{

    echo ""

    echo "+------------------------------------+"

    echo "|Coloque aqui as opções de ajuda     |"

    echo "|Dicas de uso para o protosuário !!! |"

    echo "+------------------------------------+"

    read -t 5

    return

}



# Generalizando as opções para ser reaproveitada em mais de um local.

function _opcoes()

{

# Recebe 1 parâmetro para saber o local onde está. exemplos:

# Menu principal é escolha. "$escolha", na Digitação é "$numero"

    case "$1" in

        c) cardapio ;;

        d) digitar ;;

        l) listar ;;

        f) finaliza ;;

        s) sair ;;

        h) ajuda ;;

        *) erro ;;

    esac



}



function _menu()

{

    clear

    while true

    do

        mostramenu normal

        read escolha

        _opcoes "$escolha"

    done

}



# O sistema só vai trabalhar se encontrar a tabela do cardápio.

function achou_tabela()

{

if test -e "${_FILE_CARDAPIO}"

then

    # Achou a tabela com o cardápio, vai trabalhar.

        tabela_de_precos carga # Força carregar a tabela de preços.

else

    # Falhou a busca pelo arquivo, sistema irá abortar.

    echo ""

    echo "+------------------------------------+"

    echo "|Não encontrou a tabela do cardápio: |"

    echo "|Config: ${_CONF_CARDAPIO}           |"

    echo "+------------------------------------+"

    read -t 5

    exit

fi



}



function main()

{

    achou_tabela # Verifica a existência da tabela do cardápio.

    _menu # Menu principal

}

main "${@#}"



exit



#################### "Quem pergunta é bobo por 5 minutos..." #########

######## "Quem não pergunta é bobo para sempre! (Provérbio Chinês)" ##

######################################################################