RES: [OFF] subversion: bloquear commit de arquivos com nome acentuado

[Davi Vidal]

É SIMPLES... Mas pode servir de ponto de partida... =]

Divirta-se.

[]s


> -----Mensagem original-----
> De: RicardoFunke [mailto:[EMAIL PROTECTED]
> Enviada em: quinta-feira, 22 de fevereiro de 2007 14:35
> Para: Davi Vidal
> Assunto: Re: [OFF] subversion: bloquear commit de arquivos com nome
> acentuado
> 
> opa, manda pra mim então! valeu
> 
> Em 22/02/07, Davi Vidal<[EMAIL PROTECTED]> escreveu:
> > Hmmm...
> > Quem quiser, me manda PVT que eu mando uma apostilinha de Perl que eu
> tenho
> > aqui... =]
> >
> > [EMAIL PROTECTED]
> >
> > []s
> >
> >
> > > -----Mensagem original-----
> > > De: RicardoFunke [mailto:[EMAIL PROTECTED]
> > > Enviada em: quinta-feira, 22 de fevereiro de 2007 14:26
> > > Para: debian-user-portuguese@lists.debian.org
> > > Assunto: Re: [OFF] subversion: bloquear commit de arquivos com nome
> > > acentuado
> > >
> > > massa, que pena que eu não saiba nada sobre perl
> > >
> > > Em 22/02/07, Maxwillian Miorim<[EMAIL PROTECTED]> escreveu:
> > > > On 2/21/07, RicardoFunke <[EMAIL PROTECTED]> wrote:
> > > > > Dei uma olhada sobre os hook-scripts, como fazer um script para
> isso
> > > no svn?
> > > >
> > > > Eu não sei como funcionam, mas pode usar algo para comparar
> expressões
> > > > regulares com os caracteres especiais, por exemplo:
> > > >
> > > > No hook-script, antes de tudo tu chama um script em perl que tem
> como
> > > > parâmetro o nome do arquivo. Este script verifica se o nome tem
> > > > caracteres especiais (isso é fácil com perl :). Se tiver retorna 1
> > > > senão 0.
> > > >
> > > > Depois o hook-script verifica o retorno do script de perl (vamos
> > > > chama-lo verifica_nome.pl), se for 1 continua, senão não faz nada.
> > > >
> > > > Agora tá contigo, eu vou dar uma estudada nisso porque é uma coisa
> > > > interessante... ;)
> > > >
> > > >
> > > > --
> > > > Maxwillian Miorim <[EMAIL PROTECTED]>
> > > > ----
> > > > Moo... Are you happy now?
> > > >
> > > >
> >
> >

Title: Perlintro < Perldoc < TWiki

NOME perlintro -- uma breve introdução ao Perl DESCRIÇÃO Este documento tem por intenção dar a você uma breve introdução à linguagem de programação Perl, com referências para documentações mais aprofundadas. É um guia inicial para aqueles que são novos na linguagem, e provê apenas informações para que você esteja apto a ler códigos escritos em Perl por outras pessoas e entender o que este faz, ou ainda escrever seus próprios programas iniciais. Este documento introdutório não tem por objetivo ser completo, e também não deseja ser totalmente correto. Em alguns casos, a perfeição foi sacrificada para que o objetivo de transparecer uma idéia seja alcançado. Você está avisado a seguir esta introdução com mais informações do manual encontradas no manual completo do Perl, cujo índice pode ser encontrado em perltoc. Neste documento, você encontrará referências para outras partes da documentação de Perl. Você pode ler esta documentação utilizando o comando perldoc ou o mesmo método que você está utilizando para ler este documento. O que é o Perl? O Perl é uma linguagem de programação de uso geral, originalmente desenvolvida para manipulação de textos, que agora é utilizada para uma infinidade de tarefas incluindo administração de sistemas, desenvolvimento web, programação de redes, desenvolvimento de interfaces gráficas, e muitos outros. A linguagem foi escrita para ser prática (fácil de utilizar, eficiente, completa) ao invés de bonita (pequena, elegante, mínima). Suas maiores características são sua facilidade de uso, que inclui o suporte tanto para programação procedural quanto para programação orientada à objetos, tem um poderoso suporte incluso na linguagem para processamento de textos, e uma das maiores coleções de módulos escritos por terceiros, o CPAN. Outras definições do Perl são dadas em perl, perlfaq1 e sem dúvida em outros lugares. A partir destas informações, podemos determinar que Perl é uma coisa diferente para cada pessoa, mas muitas pessoas pensam que é, no mínimo interessante, escrever sobre ela. Executando programas Perl Para executar um programa Perl, a partir da linha de comando do Unix: perl meuprograma.pl Um método alternativo é colocar isto como a primeira linha do seu script: #!/usr/bin/env perl ... e então executar seu script como /caminho/do/script.pl. O script deverá ser marcado como executável antes, então execute chmod 755 script.pl antes (no Unix). Para mais informações, incluíndo instruções para outras plataformas como Windows e Mac OS, leia perlrun. Visão básica da sintaxe Um programa ou script Perl consiste em um ou mais comandos. Cada comando é simplesmente escrito no script, um após o outro. Não há necessidade de existir uma função main() ou algo do tipo. Os comandos Perl são finalizados com um ponto-e-vírgula: print "Alo, mundo"; Os comentários inicializam com um sustenido ( #): # Isso e' um comentario Espaços em branco são irrelevantes: print "Alo, mundo" ; ... exceto dentro de strings com aspas: # isto deve imprimir o texto com uma quebra de linha no meio print "Alo mundo"; Aspas duplas ou aspas simples podem ser utilizadas em torno de strings: print "Alo, mundo"; print 'Alo, mundo'; Entretanto, apenas aquelas strings com aspas duplas podem "interpolar" variáveis e caracteres especiais como nova-linha ( \n): print "Alo, $nome\n"; # funciona! print 'Alo, $nome\n'; # exibe $nome\n literalmente Números não necessitam de aspas: print 42; Você pode utilizar parênteses para argumentos de funções ou omití-los de acordo com seu gosto. Elas são necessárias apenas para deixar claro a precedência das operações. print("Alo, mundo\n"); print "Alo, mundo\n"; Informações mais detalhadas sobre a sintaxe do Perl pode ser encontrada em perlsyn. Tipos de variáveis em Perl Perl tem três variáveis principais: scalars, arrays e hashes. Scalars Uma variável scalar representa um único valor: my $animal = "camelo"; my $resposta = 42; Valores de variáveis scalar podem ser strings, inteiros ou números com ponto flutuante. O Perl irá converter entre os tipos de acordo com a necessidade. Não é necessário pré-declarar os tipos de suas variáveis. Variáveis scalar podem ser utilizados de diversos modos: print $animal; print "O animal e' $animal\n"; print "O quadrado de $resposta e' ", $resposta * $resposta, "\n"; Existem algumas variáveis scalar "mágicas" com nomes que se parecem com pontuação ou lixo. Estas variáveis especiais são utilizadas para todos os tipos de propósitos, e estão documentadas em perlvar. A única que você precisará conhecer agora é $_, que é a "variável padrão". Ela é utilizada como o argumento padrão para um grande número de funções no Perl, e é atribuída implicitamente em algumas construções de iteração. print; # exibe o conteudo de $_ por padrao Arrays Um array representa uma lista de valores: my @animais = ("camelo", "lhama", "coruja"); my @numeros = (23, 42, 69); my @misturados = ("camelo", 42, 1.23); O índice inicial de uma variável array é zero ( 0). Esta é a maneira que você extrai elementos de um array: print $animais[0]; # exibe "camelo" print $animais[1]; # exibe "lhama" A variável especial $#array informa o índice do último elemento de um array: print $misturados[$#misturados]; # último elemento, exibe 1.23 Você pode pensar em usar $#array + 1 para informar quantos items existem em um array. Não se incomode com isso. Utilizando @array onde Perl espera encontrar um valor scalar ("em um contexto escalar"), ele irá devolver o número de elementos do array: if (@animais < 5) { ... } Os elementos que estamos extraindo do array começam com um $ porque você está extraindo um único valor do array -- você pede um valor scalar, você recebe um valor scalar. Para extrair diversos valores de uma variável array: @animais[0,1]; # devolverá ("camel", "llama"); @animais[0..2]; # devolverá ("camel", "llama", "owl"); @animais[1..$#animais]; # devolverá todos exceto o primeiro elemento Isto é chamado de "array slice". Você pode fazer diversas coisas úteis com listas: my @ordenados = sort @animais; my @invertidos = reverse @numeros; Existem diversos arrays especiais também, como @ARGV (os argumentos de linha de comando que foram passados para o seu script) e @_ (os argumentos passados para um subrotina). Estas variáveis estão documentadas em perlvar. Hashes Um hash representa uma coleção de pares de chave/valor: my %cores_de_frutas = ("morango", "vermelho", "banana", "amarelo"); Você pode utilizar um espaço em branco e o operador => para uma leitura mais agradável: my %cores_de_frutas = ( morango > "vermelho",         banana => "amarelo",     );        Para obter um elemento de um hash:            $cores_de_frutas{"morango"};           # retorna "vermelho"        Você pode obter a lista de chaves ou lista de valores com as funções  =keys() e values(). my @frutas = keys %cores_de_frutas; my @cores = values %cores_de_frutas; As variáveis hash não tem uma ordem interna particular, porém você pode ordenar as chaves (utilizando a função sort()) e iterar entre elas. Como as variáveis especiais scalar e array, existem também variáveis especiais hash. A mais conhecida delas é a variável %ENV, que contém as variáveis de ambiente. Leia tudo sobre elas (e outras variáveis especiais) em perlvar. Variáveis scalar, array e hash são documentadas mais detalhadamente em perldata. Tipos de dados mais complexos podem ser construídas utilizando referências, que permitem você construir listas e hashes dentro de listas e hashes. Uma referência é um valor scalar e pode referir-se a qualquer outro tipo de dados do Perl. Armazenando uma referência como o valor de um array ou um elemento de um hash, você pode facilmente criar listas e hashes dentro de listas e hashes. O seguinte exemplo mostra uma estrutura de hash de hash de 2 níveis utilizando referências anônimas para hash. my $variaveis = { scalar => { descricao => "item unico", simbolo => '$', }, array => { descricao => "lista ordenada de itens", simbolo => '@', }, hash => { descricao => "pares chave/valor", simbolo => '%', }, }; print "Scalars comecam com um $variaveis->{'scalar'}->{'simbolo'}\n"; Maiores informações neste tópico de referências podem ser encontradas em perlreftut, perllol, perlref e perldsc. Escopo de variáveis Apesar de todos os exemplos na seção anterior utilizarem a sintaxe:tax: my $var = "valor"; O comando my não é requerido; você pode utilizar apenas: $var = "valor"; Entretanto, a utilização acima irá criar variáveis globais em todo o seu programa, o que é uma má prática de programação. my cria uma variável em um escopo léxico, ao invés do escopo global. Estas variáveis são escopadas no bloco (isto é, diversos comandos envoltos por chaves { }) em que foram definidas. my $a = "foo"; if ($alguma_condicao) { my $b = "bar"; print $a; # exibe "foo" print $b; # exibe "bar" } print $a; # exibe "foo" print $b; # nao exibe nada; $b saiu de escopo. Utilizando my em conjunto com use strict; no início de seus scripts Perl, significa que o interpretador irá avisar certos erros de programação mais comuns. No exemplo acima, o último print $b irá causar um erro em tempo de compilação e prevenir você de executar o programa. A utilização de strict é muito recomendada. Construções condicionais e de iteração Perl possui a maioria de construções condicionais e de iteração, exceto pela construção case/switch (caso você realmente a queira, existe o módulo Switch no Perl 5.8 e mais atual, e no CPAN. Veja a seção de módulos abaixo para obter mais informações sobre módulos e CPAN). As condições podem ser qualquer expressão Perl. Veja uma lista de operadores na próxima sessão, para informações sobre comparações e operadores lógicos booleanos, que geralmente são utilizados em comandos condicionais. if if ( condição ) { ... } elsif ( outra condição ) { ... } else { ... } Existe também a versão de negação de if: unless ( condição ) { ... } Esta construção é utilizada como uma forma de leitura mais fácil de C<if(! condição)>. Note que as chaves são necessárias em Perl, mesmo que você tenha apenas uma linha no bloco. Entretanto, existe uma maneira de fazer seus blocos condicionais de uma linha parecerem mais naturais: # o modo tradicional if ($zippy) { print "Yow!"; } # o modo Perl, utilizando a condição após o comando print "Yow!" if $zippy; print "Nao temos bananas" unless $bananas; while while ( condição ) { ... } Há também a versão de negação do while, pela mesma razão que temos o unless: until ( condição ) { ... } Você também pode utilizar o while como uma pós-condição: print "LA LA LA\n" while 1; # repete para sempre for Exatamente como C: for ($i=0; $i <= $max; $i++) { ... } O estilo de iteração for do C dificilmente é necessária no Perl, pois este provê um modo mais amigavel de iterar listas, com o comando foreach. foreach foreach (@array) { print "Esse elemento e' $_\n"; } # não é necessário utilizar a variável padrão $_ foreach my $chave (keys %hash) { print "O valor de $chave e' $hash{$chave}\n"; } Para maiores detalhes em construções de iteração (e algumas que não foram mencionadas aqui) veja perlsyn. Operadores e funções embutidas O Perl vêm com uma grande seleção de funções embutidas. Algumas daquelas que nós já vimos incluem print, sort e reverse. Uma lista delas é informada no início de perlfunc e você pode facilmente obter mais infomações sobre qualquer função utilizando perldoc -f função. Operadores do Perl são documentados em detalhes em perlop, porém aqui estão alguns dos mais comuns: Aritiméticos + adição - subtração * multiplicação / divisão Comparação numérica =  igualdade     desigualdade < menor que > maior que <= menor ou igual a >= maior ou igual a Comparação de strings eq igualdade ne desigualdade lt menor que gt maior que le menor ou igual a ge maior ou igual a (Por quê separamos comparações numéricas e de string? Por que nós não temos tipos especiais de variáveis, e o Perl necessita saber quando ordenar numericamente (onde 99 é menor que 100) ou alfabeticamente (onde 100 vêm antes de 99)). Lógica booleana && and (e) || or (ou) ! not (não) ( and, or e not não estão na tabela acima como descrição dos operadores -- eles também são operadores. São mais fáceis de ler do que operadores do estilo de C, porém possuem precedências diferentes de && e amigos. Verifique perlop para maiores detalhes.) Diversos = atribuição . concatenação de string x multiplicação de string .. operador de intervalo (cria uma lista de números) -- N.T.: range operator Diversos operadores podem ser combinados com =, como por exemplo: $a += 1; # mesmo que $a = $a + 1 $a -= 1; # mesmo que $a = $a - 1 $a .= "\n"; # mesmo que $a = $a . "\n"; Arquivos e I/O Você pode abrir um arquivo para entrada ou saída de dados utilizando a função open(). Ela é documentada em detalhes em perlfunc e perlopentut. Aqui está um resumo: open(ENTRADA, "entrada.txt") or die "Nao foi possivel abrir o arquivo entrada.txt para leitura: $!"; open(SAIDA, ">saida.txt") or die "Nao foi possivel abrir o arquivo saida.txt para escrita: $!"; open(LOG, ">>meu.log") or die "Nao foi possivel abrir o arquivo meu.log em modo 'append': $!"; Você pode ler de um filehandle aberto utilizando o operador <>. No contexto escalar, ele lê uma única linha de um filehandle, e em contexto de lista lê o arquivo inteiro, atribuíndo cada linha a um elemento da lista: my $linha = <ENTRADA>; my @linhas = <ENTRADA>; Ler todo o arquivo de uma única vez é chamado slurping. Este procedimento pode ser útil porém pode trazer problemas de memória. A maioria do processamento de texto em arquivos pode ser feito uma linha por vez com as construções de iteração do Perl. O operador <> é visto com mais freqüência em um comando while: while (<ENTRADA>) { # atribui à variável $_ uma linha de cada vez print "Acabei de ler essa linha: $_"; } Nós já vimos como imprimir para a saída padrão utilizando print(). Entretanto, print() pode ter um primeiro parâmetro opcional especificando em qual filehandle ele irá imprimir: print STDERR "Este e' seu ultimo aviso.\n"; print SAIDA $registro; print LOG $mensagem; Quando você não tiver outras operações com seus filehandles abertos, você deve fechá-los (utilizando o comando close()). Sendo bem honesto, o Perl irá finalizá-los para você caso você esqueça. close ENTRADA; Expressões Regulares O suporte à expressões regulares no Perl é intensa e profunda, e é extensamente documentada em perlrequick, perretut? e outros lugares. Um resumo: Combinação simples if (/foo/) { ... } # verdadeiro se $_ contém "foo" if ($a ~ /foo/) { ... }  # verdadeiro se $a contém "foo"        O operador de combinações  =// é documentado em perlop. Ele executa a combinação por padrão na variável $_, ou pode ser utilizado em outra variável utilizando o operador =~ (também documentado em perlop). Substituições simples s/foo/bar/; # substitui foo com bar em $_ $a ~ s/foo/bar/;          # substitui foo com bar em $a     $a =~ s/foo/bar/g;        # substitui TODAS AS INSTÂNCIAS de foo com bar em $a with bar in $a        O operador de substituições  =s/// é documentado em perlop. Expressões regulares mais complexas Você não precisa fazer combinações apenas com strings fixas. Você pode combinar qualquer coisa que você quiser utilizando expressões regulares mais complexas. Elas são documentadas em perlre, porém aqui está uma consulta rápida: . um único caractere \s um caractere de espaçamento (espaço, tabulação, nova-linha) \S um caractere não-espaçamento \d um dígito (0-9) \D um caractere não-dígito \w um caractere de palavra (a-z, A-Z, 0-9, _) \W um caractere de não-palavra [aeiou] combina um único caractere do conjunto dado [^aeiou] combina com um único caractere de fora do conjunto dado (foo|bar|baz) combina com qualquer uma das alternativas especificadas ^ início da string $ final da string Quantificadores podem ser utilizados para especificar quantos items da expressão anterior você quer combinar, onde "expressão" pode ser tanto um caractere, um dos meta-caracteres listados acima, ou um grupo de caracteres ou meta-caracteres entre parênteses. * nenhum ou mais da expressão anterior + um ou mais da expressão anterior ? nenhum ou um da expressão anterior {3} combina exatamente 3 da expressão anterior {3,6} combina entre 3 e 6 da expressão anterior {3,} combina 3 ou mais da expressão anterior Alguns exemplos: /^\d+/ string que começa com um ou mais dígitos /^$/ string vazia /(\d\s){3}/ três dígitos, cada um seguido por um caractere de espaçamento (por exemplo "3 4 5 ") /(a.)+/ combina uma string em que cada par de caracteres, o primeiro seja a letra a (por exemplo "abacadaf") # Esta iteração lê da STDIN, e imprime apenas as linhas que não estão em branco: while (<>) { next if /^$/; print; } Parênteses para captura de dados Assim como agroupamento, os parênteses também servem para um segundo propósito. Eles podem ser utilizados para capturar os resultados de parte da combinação da expressão regular para posterior utilização. Os resultados são armazenados nas variáveis $1, $2 e assim por diante. # uma maneira rápida e suja de separar um endereço eletrônico em partes if ($email =~ /([EMAIL PROTECTED])@(.+)/) { print "Nome do usuario: $1\n"; print "Nome do host: $2\n"; } Outras funcionalidades das expressões regulares Expressões regulares em Perl também suportam backreferences, lookaheads e todos outros tipos de detalhes complexos. Leia sobre elas em perlrequick, perlretut e perlre. Escrevendo subrotinas Escrever subrotinas é fácil:: sub log { my $mensagem = shift; print LOGFILE $mensagem; } O que é aquele shift? Os argumentos de uma subrotina estão disponíveis através do array especial chamado @_ (veja perlvar para mais detalhes). O argumento padrão para a função shift é @_. Então, my $mensagem = shift; extrai o primeiro item da lista de argumentos e o atribui em $mensagem. Podemos manipular @_ de outras maneiras: my ($mensagem, $prioridade) = @_; # comum my $mensagem = $_[0]; # incomum, e muito feio As subrotinas podem também retornar valores: sub quadrado { my $num = shift; my $resultado = $num * $num; return $resultado; } Para maiores informações sobre como escrever subrotinas, veja perlsub. Programação orientada à objetos em Perl A programação orientada à objetos em Perl é relativamente simples e é implementada utilizando referências que sabem em qual tipo de objeto elas são baseadas, no conceito de Perl sobre o que são pacotes. Entretanto, este tipo de programação está muito além do escopo deste documento. Leia perlboot, perltoot, perltooc e perlobj. Como um programador Perl iniciante, a utilização mais comum de orientação a objetos em Perl será a utilização de módulos escritos por terceiros, que está documentada abaixo. Utilizando módulos Perl Os módulos de Perl provêm diversas funcionalidades para ajudá-lo a não reinventar a roda, e podem ser obtidos do CPAN (http://www.cpan.org/). Um grande número de módulos populares são incluídos com a distribuição padrão do Perl. As categorias dos módulos vão desde manipulação de textos à protocolos de rede e integração com banco de dados à gráficos. Uma lista categorizada dos módulos também está disponível no CPAN. Para aprender como instalar módulos obtidos do CPAN, leia perlmodinstall. Para aprender como utilizar um módulo em particular, utilize CModulo>. Geralmente você irá utilizá-lo desta maneira: CModulo>, que irá dar acesso às funções exportadas ou à interface orientada à objetos do módulo. Você encontra questões e respostas relacionadas à diversas tarefas comuns, e ainda sugestões de módulos para utilizar em perlfaq. perlmod descreve os módulos de Perl em geral. perlmodlib exibe uma listagem dos módulos que foram instalados em sua instalação Perl. Se você necessita escrever módulos para o Perl, você irá encontrar bons conselhos em perlnewmod. AUTOR Kirrily "Skud" Robert <[EMAIL PROTECTED]> TRADUÇÃO Igor Sutton <[EMAIL PROTECTED]> Esse tópico: Perldoc > Perlintro Histórico: r8 - 23 Oct 2006 - 19:46:41 - PauloSantana   Copyright © pelos autores contribuintes. Todo material nessa plataforma colaborativa é propriedade dos autores contribuintes. Idéias, solicitações, problemas com relação ao TWiki? Nos dê um retorno