darcs - Online na nuvem

PROGRAMA:

NOME

darcs - um sistema de controle de revisão avançado

SINOPSE

dardos comando <argumentos|[opções]> ...

Onde o comandos e seus respectivos argumentos e guarante que os mesmos estão

dardos ajudar [<dardos_comando> [dardos_subcomando]]
dardos adicionar <lima|anuário> ...
dardos remover <lima|anuário> ...
dardos mover <fonte> ...destino>
dardos substituir <velho>novo>lima> ...
dardos reverter [lima|anuário] ...
dardos não invertido
dardos o que há de novo [lima|anuário] ...
dardos registro [lima|anuário] ...
dardos não registrado
dardos emendar [lima|anuário] ...
dardos conflitos de marca
dardos etiqueta [nome da etiqueta]
dardos definir preferência <preferência>valor>
dardos diff [lima|anuário] ...
dardos log [lima|anuário] ...
dardos anotada [lima|anuário] ...
dardos dist
dardos teste [[inicialização] comando]
dardos mostrar conteúdo [lima] ...
dardos mostrar arquivos [lima|anuário] ...
dardos mostrar índice
dardos mostrar intocada
dardos mostrar repo
dardos mostrar autores
dardos mostrar Tag
dardos mostrar índice de patch-tudo
dardos mostrar arquivos de índice de patch
dardos mostrar status de índice de patch
dardos mostrar teste de índice de patch
dardos puxar [repositório] ...
dardos buscar [repositório] ...
dardos obliterar
dardos rollback [lima|anuário] ...
dardos empurrar [repositório]
dardos enviar [repositório]
dardos Aplique <arquivo de patch>
dardos clonar <repositório> [anuário>]
dardos inicializar [<anuário>]
dardos otimizar limpar
dardos otimizar http
dardos otimizar reordenar
dardos otimizar ativar-patch-index
dardos otimizar desativar-patch-index
dardos otimizar comprimir
dardos otimizar descomprimir
dardos otimizar religar
dardos otimizar intocada
dardos otimizar atualização
dardos otimizar esconderijo <anuário> ...
dardos reparar
dardos converter darcs-2 <fonte> [destino>]
dardos converter exportar
dardos converter importar [<anuário>]
dardos rebase puxar [repositório] ...
dardos rebase Aplique <arquivo de patch>
dardos rebase suspender
dardos rebase retirar da suspensão
dardos rebase obliterar
dardos rebase log

DESCRIÇÃO

Darcs é um sistema de controle de revisão de código aberto e gratuito. Isto é:

· Distribuído: Cada usuário tem acesso ao conjunto completo de comandos, removendo os limites entre
servidor e cliente ou committer e não committers.

· Interativo: Darcs é fácil de aprender e eficiente de usar porque faz perguntas
em resposta a comandos simples, oferecendo opções em seu fluxo de trabalho. Você pode escolher
registre uma alteração em um arquivo, enquanto ignora outra. Conforme você atualiza do upstream, você
pode revisar cada nome de patch, até mesmo o `diff 'completo para patches interessantes.

· Inteligente: Originalmente desenvolvido pelo físico David Roundy, darcs é baseado em um único
álgebra de patches. Essa inteligência permite que você responda às novas demandas de maneiras que
caso contrário, não seria possível. Saiba mais sobre ramos espontâneos com darcs.

OPÇÕES

Diferentes opções são aceitas por diferentes comandos Darcs. Cada comando é mais importante
as opções estão listadas no COMANDOS seção. Para obter uma lista completa de todas as opções aceitas por um
comando particular, execute `darcs comando --ajuda'.

Selecionando Patches:
A opção --patches produz patches com nomes que correspondem a uma expressão regular * estendida *.
See regex(7) para obter detalhes. A opção --matches produz patches que correspondem a uma lógica
Expressão (booleana): uma ou mais expressões primitivas combinadas por agrupamento (parênteses)
e os operadores de complemento (não), conjunção (e) e disjunção (ou). O C
notação para operadores lógicos (!, && e ||) também pode ser usada.

- --patches = regex é um sinônimo para --matches = 'name regex' - --hash = HASH é um sinônimo para
--matches = 'hash HASH' - --from-patch e --to-patch são sinônimos para --from-match = 'nome ...
e --to-match = 'name ... - --from-patch e --to-match podem ser combinados sem problemas:
`darcs changes --from-patch = 'html. * documentation' --to-match = 'date 20040212'`

As seguintes expressões booleanas primitivas são suportadas:

- exato - verifica uma string literal em relação ao nome do patch. - nome - verifique um regular
expressão contra o nome do patch. - autor - verifica uma expressão regular em relação ao
nome do autor. - hunk - verifica uma expressão regular em relação ao conteúdo de um patch hunk. -
comentário - compare uma expressão regular com a mensagem de log. - hash - corresponde a um hash completo
ou um prefixo para um patch. - data - corresponde à data do patch. - toque - corresponder caminhos de arquivo para um
patch.

aqui estão alguns exemplos:

darcs annotate --summary --match 'exact "Resolver problema17: usar memória dinâmica
atribuição. "'
darcs annotate --summary --match 'name issue17'
darcs annotate --summary --match 'name "^ [Rr] esolve issue17 \>"'
darcs annotate --summary --match 'autor "David Roundy"'
darcs annotate --summary --match 'autor droundy'
darcs annotate --summary --match 'autor [email protegido]'
darcs annotate --summary --match 'hunk "foo = 2"'
darcs annotate --summary --match 'hunk "^ instance. * Foo where $"'
darcs annotate --summary --match 'comentário "prevenir impasses"'
darcs annotate --summary --match 'hash c719567e92c3b0ab9eddd5290b705712b8b918ef'
darcs annotate --summary --match 'hash c7195'
darcs annotate --summary --match 'date "2006-04-02 22:41"'
darcs annotate --summary --match 'date "tea time yesterday"'
darcs annotate --summary --match 'touch src / foo.c'
darcs annotate --summary --match 'touch src /'
darcs annotate --summary --match 'touch "src / *. (c | h)"'

COMANDOS

dardos ajudar [<dardos_comando> [dardos_subcomando]]
Sem argumentos, `darcs help` imprime uma lista categorizada de comandos darcs e um
breve descrição de cada um. Com um argumento extra, `darcs help foo` prints
ajuda detalhada sobre o comando darcs foo.

Mudar e consultando que o trabalhar cópia:
dardos adicionar <lima|anuário> ...
Geralmente, um repositório contém ambos os arquivos que devem ser controlados por versão (como
código-fonte) e arquivos que Darcs deve ignorar (como executáveis ​​compilados a partir do
Código fonte). O comando `darcs add` é usado para dizer ao Darcs quais arquivos versão
controlar.

Quando um projeto existente é importado pela primeira vez para um repositório Darcs, é comum
execute `darcs add -r *` ou `darcs record -l` para adicionar todos os arquivos-fonte iniciais ao darcs.

Adicionar links simbólicos (links simbólicos) não é suportado.

Darcs irá ignorar todos os arquivos e pastas que parecem "chatos". A opção `--boring`
substitui esse comportamento.

Darcs não adicionará arquivo se outro arquivo na mesma pasta tiver o mesmo nome, exceto
para o caso. A opção `--case-ok` substitui este comportamento. Windows e OS X geralmente
use sistemas de arquivos que não permitem que os arquivos de uma pasta tenham o mesmo nome, exceto no caso
(por exemplo, `ReadMe` e` README`). Se `--case-ok` for usado, o repositório pode ser
inutilizável nesses sistemas!

dardos remover <lima|anuário> ...
O comando `darcs remove` existe principalmente para simetria com` darcs add`, como o
maneira normal de remover um arquivo do controle de versão é simplesmente excluí-lo do
árvore de trabalho. Este comando só é útil no caso incomum em que se deseja
gravar um patch de remoção SEM deletar a cópia na árvore de trabalho (que pode ser
adicionado novamente).

Observe que aplicar um patch de remoção a um repositório (por exemplo, puxando o patch) irá
SEMPRE afete a árvore de trabalho desse repositório.

dardos mover <fonte> ...destino>
Darcs não consegue distinguir com segurança entre um arquivo que está sendo excluído e um novo adicionado,
e um arquivo sendo movido. Portanto, Darcs sempre assume o primeiro, e fornece o
Comando `darcs mv` para permitir que Darcs saiba quando você deseja o último. Este comando também
mover o arquivo na árvore de trabalho (ao contrário de `darcs remove`), a menos que já tenha sido
se mudou.

Darcs não renomeará um arquivo se outro arquivo na mesma pasta tiver o mesmo nome,
exceto para o caso. A opção `--case-ok` substitui este comportamento. Windows e OS X
geralmente usam sistemas de arquivos que não permitem que arquivos de uma pasta tenham o mesmo nome, exceto
para o caso (por exemplo, `ReadMe` e` README`). Se `--case-ok` for usado, o repositório
pode ser inutilizável nesses sistemas!

dardos substituir <velho>novo>lima> ...
Além de patches baseados em linha, Darcs oferece suporte a uma forma limitada de
substituição. Os arquivos são tratados como sequências de palavras, e cada ocorrência do antigo
palavra é substituída pela nova palavra. O objetivo é fornecer uma maneira limpa de renomear um
função ou variável. Essas renomeações normalmente afetam as linhas em toda a fonte
código, então um patch tradicional baseado em linha provavelmente entraria em conflito com outro
ramos, exigindo mesclagem manual.

Os arquivos são tokenizados de acordo com uma regra simples: palavras são strings de token válido
caracteres, e tudo entre eles (pontuação e espaço em branco) é descartado. Por
padrão, os caracteres de token válidos são letras, números e o sublinhado (ou seja,
`[A-Za-z0-9_]`). No entanto, se o token antigo e / ou novo contiver um hífen ou
ponto, AMBOS o hífen e o ponto são considerados válidos (ou seja, `[A-Za-z0-9 _.-]`).

O conjunto de caracteres válidos pode ser personalizado usando a opção `--token-chars`. O
o argumento deve estar entre colchetes. Se um hífen ocorrer entre dois
caracteres no conjunto, ele é tratado como um intervalo definido. Por exemplo, na maioria das localidades
`[AZ]` denota todas as letras maiúsculas. Se o primeiro caractere for um circunflexo, válido
os tokens são considerados o complemento dos caracteres restantes. Por exemplo,
`[^: \ n]` poderia ser usado para combinar campos no passwd(5), onde os registros e campos são
separados por novas linhas e dois pontos, respectivamente.

Se você escolher usar `--token-chars`, você é fortemente encorajado a fazê-lo
consistentemente. As consequências de usar vários patches de substituição com diferentes
Argumentos `--token-chars` no mesmo arquivo não são bem testados nem bem compreendidos.

Por padrão, Darcs se recusará a realizar uma substituição se o novo token já estiver em
uso, porque as substituições não seriam distinguíveis das existentes
tokens. Este comportamento pode ser sobrescrito fornecendo a opção `--force`, mas um
tentativa de `darcs rollback`, o patch resultante afetará esses tokens existentes.

Limitações:

O tokenizer trata os arquivos como strings de byte, portanto não é possível para `--token-chars`
para incluir caracteres multibyte, como as partes não ASCII de UTF-8. Similarmente,
tentar substituir um caractere de "bit alto" de uma codificação unibyte também resultará em
substituição do mesmo byte em arquivos com codificações diferentes. Por exemplo, um agudo
a do ISO 8859-1 também corresponderá a um alfa do ISO 8859-7.

Devido a limitações no formato do arquivo de patch, os argumentos `--token-chars` não podem conter
espaço em branco literal. Por exemplo, `[^ \ n \ t]` não pode ser usado para declarar todos os caracteres
exceto o espaço, tabulação e nova linha como válidos dentro de uma palavra, porque contém um
espaço literal.

Ao contrário do POSIX regex(7) expressões de colchetes, classes de caracteres (como `[[: alnum:]]`)
NÃO são suportados por `--token-chars`, e serão silenciosamente tratados como um simples conjunto de
caracteres.

dardos reverter [lima|anuário] ...
O comando `darcs revert` descarta mudanças não registradas na árvore de trabalho. Como com
`darcs record`, você será questionado sobre quais pedaços (mudanças) reverter. A opção `--all`
pode ser usado para evitar tal solicitação. Se arquivos ou diretórios forem especificados, outro
partes da árvore de trabalho não são revertidas.

Em você acidentalmente reverteu algo que queria manter (por exemplo, digitando `darcs
rev -a` em vez de `darcs rec -a`), você pode executar imediatamente` darcs unrevert` para
restaure-o. Isso só é garantido que funcione se o repositório não mudou desde
`darcs revert` correu.

dardos não invertido
Desfazer é um comando de resgate no caso de você acidentalmente reverter algo que queria
keep (por exemplo, digitando `darcs rev -a` em vez de` darcs rec -a`).

Este comando pode falhar se o repositório mudou desde que a reversão ocorreu.
Darcs irá pedir confirmação antes de executar um comando interativo que irá
DEFINITIVAMENTE, evite a reversão.

dardos o que há de novo [lima|anuário] ...
O comando `darcs whatsnew` lista mudanças não registradas na árvore de trabalho. Se vocês
especificar um conjunto de arquivos e diretórios, apenas alterações não registradas nesses arquivos e
os diretórios são listados.

Com a opção `--summary`, as mudanças são condensadas em uma linha por arquivo, com
mnemônicos para indicar a natureza e extensão da mudança. O `--look-for-adds`
opção faz com que os candidatos para `darcs add` sejam incluídos na saída do resumo.
Os mnemônicos resumidos são os seguintes:

* `A f` e` A d / `respectivamente significam um arquivo ou diretório adicionado. * `R f` e` R d / `
respectivamente significa um arquivo ou diretório removido. * `M f -N + M rP` significa um modificado
arquivo, com `N` linhas excluídas,` M`
linhas adicionadas e substituições lexicais `P`. * `f -> g` significa um arquivo movido ou
diretório. * `af` e` ad / `respectivamente significam um novo, mas não adicionado, arquivo ou
diretório, ao usar `--look-for-adds`.

Um ponto de exclamação (!) Como em `R! foo.c`, significa que o pedaço é conhecido por
conflito com um pedaço em outro patch. A frase `duplicado`
significa que o pedaço é idêntico a um pedaço em outro patch.

Por padrão, `darcs whatsnew` usa o formato interno do Darcs para alterações. Para ver alguns
contexto (linhas inalteradas) em torno de cada mudança, use a opção `--unified`. Ver
mudanças no formato `diff` convencional, use o comando` darcs diff`; mas note que
`darcs whatsnew` é mais rápido.

Este comando sai sem sucesso (retorna um status de saída diferente de zero) se não houver
alterações não registradas.

Copiar alterar entre que o trabalhar cópia e que o repositório:
dardos registro [lima|anuário] ...
O comando `darcs record` é usado para criar um patch de mudanças na árvore de trabalho.
Se você especificar um conjunto de arquivos e diretórios, as alterações em outros arquivos serão ignoradas.

Cada patch tem um nome, uma descrição opcional, um autor e uma data.

Darcs irá lançar um editor de texto (veja `darcs help environment`) após o interativo
seleção, para permitir que você insira o nome do patch (primeira linha) e a descrição do patch
(linhas subsequentes).

O nome do patch deve ser uma frase curta que descreve concisamente o patch, como
"Adicionar tratamento de erros ao loop de evento principal." Você pode fornecê-lo com antecedência com o `-m`
opção, caso em que nenhum editor de texto é iniciado, a menos que você use o
opção `--edit-long-comment`.

A descrição do patch é um bloco opcional de texto de formato livre. É usado para fornecer
informações adicionais que não cabem no nome do patch. Por exemplo, pode
inclua uma justificativa de PORQUE a mudança foi necessária.

Uma diferença técnica entre o nome do patch e a descrição do patch é a correspondência com
a sinalização `-p` é feita apenas em nomes de patch.

Finalmente, a opção `--logfile` permite que você forneça um arquivo que já contém o
nome e descrição do patch. Isso é útil se um registro anterior falhou e deixou
um arquivo `darcs-record-0`.

Cada patch é atribuído ao seu autor, geralmente por endereço de e-mail (por exemplo, `Fred
Bloggs[email protegido]> `). Darcs procura em vários lugares por esta string de autor:
a opção `--author`, os arquivos` _darcs / prefs / author` (no repositório) e
`~ / .darcs / autor`(em seu diretório inicial), e as variáveis ​​de ambiente
`$ DARCS_EMAIL` e` $ EMAIL`. Se nenhum desses existir, Darcs irá solicitar a você um
string de autor e escrever em `~ / .darcs / autor`. Observe que se você tiver mais de um
endereço de e-mail, você pode colocá-los todos em `~ / .darcs / autor`, um autor por linha. Darcs
ainda solicitará um autor, mas permite que você selecione na lista ou
digite uma alternativa.

Se você deseja definir manualmente quaisquer dependências extras para o seu patch, você pode usar o
Sinalizador `--ask-deps`, e darcs irá perguntar sobre as dependências do patch. Algum
dependências podem ser inferidas automaticamente do conteúdo do patch e não podem ser
removido. Um patch com dependências específicas pode estar vazio.

A data do patch é gerada automaticamente. Ele só pode ser falsificado usando o
opção `--pipe`.

Se você executar o registro com a opção `--pipe`, será solicitada a data do patch,
autor, e o comentário longo. O comentário longo se estenderá até o final do arquivo ou
stdin é alcançado (ctrl-D em sistemas Unixy, ctrl-Z em sistemas executando um sistema operacional Microsoft).

Esta interface é projetada para darcs de script, em particular para escrever repositório
scripts de conversão. Os prompts são principalmente um guia útil (uma vez que os scripts
não precisará deles), para ajudá-lo a entender o formato no qual fornecer a entrada.
Aqui está um exemplo de como os prompts do `--pipe` se parecem:

Qual é a data? Seg, 15 de novembro 13:38:01 EST 2004
Quem é o autor? David Roundy
Qual é o log? Uma ou mais linhas de comentário

Se um comando de teste foi definido com `darcs setpref`, tentando gravar um patch
fará com que o comando de teste seja executado em uma cópia limpa da árvore de trabalho (ou seja,
incluindo apenas as alterações registradas). Se o teste falhar, você terá que abortar o
operação de registro.

A opção `--set-scripts-executable` faz com que os scripts se tornem executáveis ​​no
cópia limpa da árvore de trabalho, antes de executar o teste. Veja `darcs clone` para um
explicação da heurística do script.

Se o seu comando de teste é tediosamente lento (por exemplo, `make all`) e você está gravando vários
patches em uma linha, você pode querer usar `--no-test` para pular todos, exceto o teste final.

Para ver algum contexto (linhas inalteradas) em torno de cada mudança, use a opção `--unified`.

dardos não registrado
Unrecord faz o oposto do registro: ele apaga patches do repositório, sem
alterando a cópia de trabalho. A exclusão de patches do repositório torna as mudanças ativas
novamente, que você pode gravar ou reverter mais tarde. Esteja ciente de que você não deve usar este
comando se houver a possibilidade de que outro usuário já pode ter retirado o patch.

dardos emendar [lima|anuário] ...
Amend atualiza um patch "rascunho" com adições ou melhorias, resultando em um único
patch "concluído".

Por padrão, `alterar` propõe que você registre alterações adicionais. Se ao invés você quiser
remova as alterações, use a flag `--unrecord`.

Ao gravar um patch de rascunho, é uma boa idéia começar o nome com `DRAFT:`. Quando
feito, remova-o com `darcs alteração --edit-long-comment`. Alternativamente, para alterar o
nome do patch sem iniciar um editor, use a sinalização `--name` /` -m`:

darcs alterar --match 'nome "RASCUNHO: foo"' --name 'foo2'

Como o `registro darcs`, se você chamar alterar com arquivos como argumentos, você só será solicitado
sobre as mudanças nesses arquivos. Então, para alterar um patch para foo.c com melhorias em
bar.c, você executaria:

darcs alterar --match 'touch foo.c' bar.c

Normalmente, é uma má ideia corrigir o patch de outro desenvolvedor. Para fazer emendas apenas pergunte
sobre seus próprios patches por padrão, você pode adicionar algo como `corrigir correspondência David
Roundy` para `~ / .darcs / defaults`, onde` David Roundy` é o seu nome.

dardos conflitos de marca
Darcs requer orientação humana para unificar as alterações na mesma parte de um arquivo de origem.
Quando um conflito ocorre pela primeira vez, darcs irá adicionar o estado inicial e ambas as opções ao
árvore de trabalho, delimitada pelos marcadores `vvv`,` ===== `,` * * * `e` ^ ^ ^ `, como
segue:

vvvvvvv
Estado inicial.
=============
Primeira escolha.
*************
Segunda chance.
^^^^^^^^^^

No entanto, você pode reverter ou excluir manualmente esses marcadores sem realmente resolver
o conflito. Neste caso, `darcs mark-concepts` é útil para mostrar onde estão os
conflitos não resolvidos. Também é útil se `darcs apply` for chamado com
`--apply-concepts`, onde os conflitos não são marcados inicialmente.

A menos que você use a opção `--dry-run`, quaisquer alterações não registradas na árvore de trabalho IRÃO
estará perdido para sempre quando você executar este comando! Você será solicitado a confirmar
antes que isso aconteça.

direto modificação of que o repositório:
dardos etiqueta [nome da etiqueta]
O comando `darcs tag` nomeia o estado do repositório atual, para que possa ser facilmente
referido mais tarde. Cada estado * importante * deve ser marcado; em particular é bom
prática para marcar cada versão estável com um número ou codinome. Conselhos sobre o lançamento
a numeração pode ser encontrada emhttp://producingoss.com/en/development-cycle.html>.

Para reproduzir o estado de um repositório `R` como na tag` t`, use o comando `darcs clone
--tag t R`. O comando `darcs show tags` lista todas as tags no repositório atual.

A marcação também oferece benefícios de desempenho significativos: quando o Darcs chega a um
tag que depende de todos os patches anteriores, pode simplesmente parar o processamento.

Como patches normais, uma tag tem um nome, um autor, um timestamp e um opcional longo
descrição, mas não muda a árvore de trabalho. Uma tag pode ter qualquer nome, mas
geralmente é melhor escolher um esquema de nomenclatura e segui-lo.

Por padrão, uma tag nomeia todo o estado do repositório no momento em que a tag é criada. Se
a opção --ask-deps é usada, os patches a serem incluídos como parte da tag podem ser
selecionados explicitamente.

O comando `darcs tag` aceita a opção` --pipe`, que se comporta conforme descrito em
`registro darcs`.

dardos definir preferência <preferência>valor>
Ao trabalhar em um projeto com vários repositórios e colaboradores, às vezes é
desejável que uma preferência seja definida de forma consistente em todo o projeto. Isso é alcançado por
tratar um conjunto de preferências com `darcs setpref` como uma alteração não registrada, que pode então
ser gravado e tratado como qualquer outro patch.

As preferências válidas são:

* test - um comando shell que executa testes de regressão * predist - um comando shell para
executar antes de `darcs dist '* boringfile - o caminho para um arquivo chato controlado por versão *
binariesfile - o caminho para um arquivo binários controlado por versão

Por exemplo, um projeto usando GNU autotools, com um alvo `make test` para executar
testes de regressão, podem permitir o teste de regressão integrado de Darcs com o seguinte
comando:

darcs setpref test 'autoconf && ./configure && make && make test'

Observe que a fusão não está atualmente implementada para preferências: se dois patches tentarem
para definir a mesma preferência, o último patch aplicado ao repositório sempre levará
precedência. Isso é considerado um bug de baixa prioridade, porque as preferências raramente são
definido.

Consultando que o repositório:
dardos diff [lima|anuário] ...
O comando `darcs diff` compara duas versões da árvore de trabalho do atual
repositório. Sem opções, as árvores de trabalho intactas (gravadas) e não gravadas são
comparados. Este é um nível mais baixo do que o comando `darcs whatsnew`, uma vez que produz um
diferença linha por linha, e também é mais lento. Tal como acontece com `darcs whatsnew`, se você especificar
arquivos ou diretórios, as alterações em outros arquivos não são listadas. O comando sempre usa
um utilitário diff externo.

Com a opção `--patch`, a comparação será feita entre as árvores de trabalho com e
sem esse patch. Patches * após * o patch selecionado não estão presentes em nenhum dos
as árvores de trabalho comparadas. As opções `--from-patch` e` --to-patch` permitem a configuração
de patches nas árvores de trabalho `antiga 'e` nova' a serem especificados separadamente.

A tag associada e as opções de correspondência também são compreendidas, por exemplo, `darcs diff --from-tag
1.0 - para marcar 1.1`. Todas essas opções pressupõem uma ordem do conjunto de patches, portanto, os resultados
pode ser afetado por operações como `darcs optimize --reorder`.

diff(1) é chamado com os argumentos `-rN`. A opção `--unified` faz com que` -u` seja
passado para diff(1). Um argumento adicional pode ser passado usando `--diff-opts`, como
`--diff-opts = -ud` ou` --diff-opts = -wU9`.

A opção `--diff-command` pode ser usada para especificar um utilitário alternativo, como
meld (GNOME) ou opendiff (OS X). Os argumentos podem ser incluídos, separados por espaços em branco.
O valor não é interpretado por um shell, portanto, construções de shell não podem ser usadas. O
os argumentos% 1 e% 2 DEVEM ser incluídos, eles são substituídos pelas duas árvores de trabalho
sendo comparados. Se esta opção for usada, `--diff-opts` será ignorado.

dardos log [lima|anuário] ...
O comando `darcs log` lista os patches que constituem o repositório atual ou,
com `--repo`, um repositório remoto. Sem opções ou argumentos, TODOS os patches serão
listados.

Quando dados um ou mais arquivos ou diretórios como argumentos, apenas patches que afetam
esses arquivos ou diretórios são listados. Isso inclui patches que aconteceram com arquivos
antes de serem movidos ou renomeados.

Quando dado um `--from-tag`,` --from-patch` ou `--from-match`, apenas patches desde então
tag ou patch são listados. Da mesma forma, o `--to-tag`,` --to-patch` e `--to-match`
opções restringem a lista a patches mais antigos.

As opções `--last` e` --max-count` limitam o número de patches listados. O
O primeiro se aplica ANTES de outros filtros, enquanto o último se aplica DEPOIS de outros filtros.
Por exemplo, `darcs log foo.c --max-count 3` irá imprimir os últimos três patches que
afeta foo.c, enquanto `darcs log --last 3 foo.c` irá, dos últimos três patches,
imprime apenas aqueles que afetam foo.c.

Existem três formatos de saída. O padrão é `--human-readable`. Você também pode selecionar
`--context`, que é o formato interno (como visto em pacotes de patch) que pode ser
relido por Darcs (por exemplo, `darcs clone --context`).

Finalmente, há `--xml-output`, que emite XML válido ... a menos que os metadados do patch
(autor, nome ou descrição) contém um caractere não ASCII e foi gravado em um
localidade não UTF8.

Observe que embora a sinalização `--context` possa ser usada em conjunto com` --xml-output` ou
`--human-readable`, em nenhum dos casos o darcs clone será capaz de ler a saída. Sobre
por outro lado, serão emitidas informações suficientes para que um ser humano experiente
recriar o estado atual do repositório.

dardos anotada [lima|anuário] ...
O comando `darcs annotate` fornece duas operações não relacionadas. Quando chamado em um
, ele encontrará o patch que modificou cada linha desse arquivo pela última vez. Quando chamado
em um patch (por exemplo, usando `--patch`), ele irá imprimir a representação interna desse
patch.

A opção `--summary` resultará em uma anotação de patch resumida, semelhante a` darcs
o que há de novo. Não tem efeito nas anotações do arquivo.

Por padrão, a saída está em um formato legível por humanos. A opção `--machine-readable` pode
ser usado para gerar saída para o pós-processamento da máquina.

dardos dist
`darcs dist` cria um arquivo compactado no diretório raiz do repositório,
contendo o estado gravado da árvore de trabalho (mudanças não registradas e o `_darcs`
diretório são excluídos). O comando aceita matchers para criar um arquivo de alguns
estado do repositório passado, por exemplo `--tag`.

Por padrão, o arquivo (e o diretório de nível superior dentro do arquivo) tem o mesmo
nome como o repositório, mas isso pode ser sobrescrito com a opção `--dist-name`.

Se um comando predist for definido (veja `darcs setpref`), esse comando será executado no
estado gravado antes do arquivamento. Por exemplo, projetos autotools configurariam para
`autoconf && automake`.

Se `--zip` for usado, os matchers e o comando predist são ignorados.

dardos teste [[inicialização] comando]
Execute o teste no estado atual registrado do repositório. Sem argumentos, ele usa
o teste de repositório padrão (veja `darcs setpref`). Dado um argumento, ele o trata
como um comando de teste. Dados dois argumentos, o primeiro é um comando de inicialização e
o segundo é o teste (o que significa que o código de saída do primeiro comando não é levado em
conta para determinar o sucesso do teste). Se for fornecido o `--linear` ou` --bisect`
sinalizadores, ele tenta encontrar a versão mais recente no repositório que passa no teste.

`--linear` faz uma pesquisa linear começando da cabeça e se afastando da cabeça. Isto
estratégia é melhor quando o teste é executado muito rapidamente ou o patch que você está procurando está próximo
a cabeça.

`--bisect` faz pesquisa binária. Essa estratégia é melhor quando o teste é executado muito lentamente
ou o patch que você está procurando provavelmente está no passado distante do repositório.

`--backoff` começa a pesquisar a partir da cabeça, pulando mais e mais no passado
até que o teste seja bem-sucedido. Em seguida, ele faz uma pesquisa binária em um subconjunto daqueles que foram ignorados
patches. Esta estratégia funciona bem, a menos que o patch que você está procurando esteja no
passado distante do repositório.

Partindo do pressuposto de que a falha é monótona, `--linear` e` --bisect` produzem o
mesmo resultado. (Monótono significa que quando se afasta da cabeça, o resultado do teste
muda apenas uma vez de "falha" para "ok".) Se a falha não for monótona, qualquer um dos
patches que quebram o teste são encontrados aleatoriamente.

dardos mostrar conteúdo [lima] ...
Mostrar conteúdo pode ser usado para exibir uma versão anterior de alguns arquivos. Se você der
mostrar conteúdo sem argumentos de versão, ele exibe a versão gravada do (s) arquivo (s).

dardos mostrar arquivos [lima|anuário] ...
O comando `darcs show files` lista esses arquivos e diretórios na árvore de trabalho
que estão sob controle de versão. Este comando é principalmente para fins de script; fim
os usuários provavelmente irão querer `darcs whatsnew --summary`.

Um arquivo está "pendente" se tiver sido adicionado, mas não gravado. Por padrão, arquivos pendentes
(e diretórios) são listados; a opção `--no-pending` evita isso.

Por padrão, `darcs show files` lista os arquivos e diretórios, mas o apelido` darcs
show manifest` lista apenas arquivos. Os `--files`,` --directories`, `--no-files` e
`--no-directory` modifica este comportamento.

Por padrão, as entradas são uma por linha (ou seja, separadas por nova linha). Isso pode causar problemas
se os próprios arquivos contêm novas linhas ou outros caracteres de controle. Passear
para isso, a opção `--null` usa o caractere nulo. O script interpretando
a saída desse comando precisa entender esse idioma; `xargs -0` é um desses comandos.

Por exemplo, para listar arquivos controlados por versão por tamanho:

darcs mostrar arquivos -0 | xargs -0 ls -ldS

dardos mostrar índice
O comando `darcs show index` lista todos os arquivos e diretórios controlados por versão
junto com seus hashes armazenados em `_darcs / index`. Para arquivos, os campos correspondem
para o tamanho do arquivo, sha256 do conteúdo do arquivo atual e o nome do arquivo.
dardos mostrar intocada
O comando `darcs show pristine` lista todos os arquivos e diretórios controlados por versão
junto com os hashes de suas cópias originais. Para arquivos, os campos correspondem a
tamanho do arquivo, sha256 do conteúdo do arquivo original e o nome do arquivo.
dardos mostrar repo
O comando `darcs show repo` exibe estatísticas sobre o repositório atual,
permitindo que scripts de terceiros acessem essas informações sem inspecionar `_darcs`
diretamente (e sem quebrar quando o formato `_darcs` muda).

Por padrão, o número de patches é mostrado. Se esses dados não forem necessários, use
`--no-files` para acelerar este comando de O (n) para O(1).

Por padrão, a saída está em um formato legível por humanos. A opção `--xml-output` pode ser
usado para gerar saída para pós-processamento da máquina.

dardos mostrar autores
O comando `darcs show owners` lista os autores do repositório atual, classificados
pelo número de patches contribuídos. Com a opção `--verbose`, este comando
simplesmente lista o autor de cada patch (sem agregação ou classificação).

O nome ou endereço de e-mail de um autor pode mudar com o tempo. Para dizer a Darcs quando múltiplos
strings de autor referem-se ao mesmo indivíduo, crie um arquivo `.authorspellings` no
raiz da árvore de trabalho. Cada linha neste arquivo começa com um canônico do autor
nome e endereço, e pode ser seguido por uma lista separada por vírgulas de
expressões. Linhas em branco e linhas que começam com dois hifens são ignoradas. O
formato de `.authorspelling` pode ser descrito por este padrão:

nome [, regexp] *

Existem algumas armadilhas em relação aos caracteres especiais: os espaços em branco são removidos, se
você precisa de espaço em regexp use []. Porque a vírgula serve como um separador, você deve
escape se quiser em regexp. Observe que `.authorspelling` usa extensão regular
expressões tão +,? e assim por diante são metacaracteres e você precisa escapar deles para ser
interpretado literalmente.

Qualquer patch com uma string de autor que corresponda ao endereço canônico ou qualquer um dos
regexps associadas é considerado o trabalho desse autor. Todas as correspondências são
não diferencia maiúsculas de minúsculas e parcial (pode corresponder a uma substring). Use ^, $ para combinar o todo
string em regexps

Atualmente, esta etapa de canonização é feita apenas em `darcs show owners`. De outros
comandos, como `darcs log` usam strings de autor literalmente.

Um exemplo de arquivo `.authorspelling` é:

- Este é um comentário.
Fred Nurk[email protegido]>
John Snagge[email protegido]>, John, snagge @, js @ (si | mit) .edu
Chuck Jones \, Jr.[email protegido]>, cj \ +[email protegido]

dardos mostrar Tag
O comando tags grava uma lista de todas as tags no repositório para a saída padrão.

Os caracteres de tabulação (caractere ASCII 9) em nomes de tag são alterados para espaços para melhor
interoperabilidade com ferramentas shell. Um aviso é impresso se isso acontecer.

dardos mostrar índice de patch-tudo
O comando `darcs show patch-index all 'lista todas as informações no índice de patch
dardos mostrar arquivos de índice de patch
O comando `darcs show patch-index files 'lista todos os arquivos atuais registrados no
índice de patch
dardos mostrar status de índice de patch
Os relatórios `darcs show patch-index-status 'se o índice do patch está sincronizado, fora do
sincronizar ou não existe
dardos mostrar teste de índice de patch
O `darcs show patch-index-test 'testa o índice de patch

Copiar remendos entre repositórios de trabalhar cópia atualizar:
dardos puxar [repositório] ...
Pull é usado para trazer patches feitos em outro repositório para o repositório atual
(ou seja, aquele no diretório atual ou aquele especificado com o
opção `--repodir`). Pull permite que você traga todos ou alguns dos patches que são
nesse repositório, mas não neste. Pull aceita argumentos, que são URLs de
qual puxar, e quando chamado sem um argumento, puxar usará o repositório de
que você empurrou ou puxou mais recentemente.

O comportamento padrão (`--union`) é puxar todos os patches que estão em qualquer um dos
repositórios especificados. Se você especificar o sinalizador `--intersection`, darcs irá apenas
extraia os patches que estão presentes em todos os repositórios de origem. Se você especificar o
sinalizador `--complement`, darcs só irá puxar elementos no primeiro repositório que não
existem em qualquer um dos repositórios restantes.

Se `--reorder` for fornecido, o conjunto de patches que existe apenas no atual
repositório é colocado no topo da história atual. Isso funcionará mesmo se houver
não há novos patches para puxar.

Veja `darcs help apply` para uma descrição detalhada de muitas opções.

dardos buscar [repositório] ...
Fetch é semelhante a `pull`, exceto que não aplica nenhum patch ao atual
repositório. Em vez disso, ele gera um pacote de patch que você pode aplicar mais tarde com
`aplicar`.

O comportamento do Fetch é essencialmente semelhante ao do pull, então consulte a ajuda de
`pull` para saber mais.

dardos obliterar
Obliterate remove completamente os patches gravados de seu repositório local. As mudanças
será desfeito na sua cópia de trabalho e os patches não serão mostrados nas suas alterações
lista mais. Esteja ciente de que você pode perder códigos preciosos ao obliterar!

Uma maneira de salvar patches obliterados é usar o sinalizador -O. Um pacote de patch será
criado localmente, que você poderá aplicar posteriormente ao seu repositório com `darcs
aplicar ».

dardos rollback [lima|anuário] ...
Rollback é usado para desfazer os efeitos de algumas mudanças de patches no repositório.
As mudanças selecionadas são desfeitas em sua cópia de trabalho, mas o repositório é deixado
inalterado. Primeiro, é oferecida a você uma escolha de quais patches desfazer e, em seguida, quais alterações
dentro dos patches para desfazer.

Antes de fazer o `rollback`, você pode querer desfazer temporariamente as mudanças de seu trabalho
copie (se houver) e salve-os para uso posterior. Para fazer isso, você pode executar `revert`, então
execute `rollback`, grave um patch e execute` unrevert` para restaurar as alterações salvas em
sua cópia de trabalho.

dardos empurrar [repositório]
Empurrar é o oposto de puxar. Push permite que você copie patches do atual
repositório em outro repositório.

Se você fornecer o sinalizador `--apply-as`, darcs usará sudo para aplicar os patches como um
usuário diferente. Isso pode ser útil se você deseja configurar um sistema onde vários usuários
pode modificar o mesmo repositório, mas você não deseja permitir a eles acesso de gravação total.
Isso não é seguro contra invasores mal-intencionados, mas pelo menos pode proteger seu
repositório de usuários desajeitados, ineptos ou preguiçosos.

O push Darcs irá, por padrão, compactar os dados do patch antes de enviá-los para um controle remoto
localização via ssh. Isso funciona, desde que o darcs remoto não seja mais antigo que a versão
2.5. Se você receber erros que indicam um pacote de patch corrompido, você deve tentar novamente com
a opção `--no-compress` para enviar os dados na forma não compactada (o que é muito
mais lento para patches grandes, mas sempre deve funcionar).

dardos enviar [repositório]
Send é usado para preparar um pacote de patches que podem ser aplicados a um alvo
repositório. Send aceita a URL do repositório como argumento. Quando chamado
sem um argumento, enviar usará o repositório mais recente que foi enviado
para, puxado de ou enviado para. Por padrão, o pacote de patch é salvo em um arquivo, embora
você pode enviá-lo diretamente pelo correio.

Os sinalizadores `--output`,` --output-auto-name` e `--to` determinam o que darcs faz com
o pacote de patch após criá-lo. Se você fornecer um argumento `--output`, o patch
pacote é salvo nesse arquivo. Se você especificar `--output-auto-name`, o pacote de patch
é salvo em um arquivo com um nome gerado automaticamente. Se você der um ou mais
argumentos `--to`, o pacote de patches é enviado para esses locais. Os locais podem
podem ser endereços de e-mail ou urls para os quais o patch deve ser enviado via HTTP.

Se você fornecer o sinalizador `--mail`, darcs irá olhar o conteúdo do
arquivo `_darcs / prefs / email` no repositório de destino (se existir), e envie o patch
por e-mail para esse endereço. Neste caso, você pode usar a opção `--cc` para especificar
destinatários adicionais sem substituir o endereço de e-mail do repositório padrão.

Se `_darcs / prefs / post` existe no repositório de destino, darcs irá carregar para a URL
contido naquele arquivo, que pode ser um URL `mailto:` ou um URL `http: //`. Dentro
no último caso, o patch é postado nesse URL.

Se não houver endereço de e-mail associado ao repositório, darcs irá solicitar
um endereço de email.

Use o sinalizador `--subject` para definir o assunto do e-mail a ser enviado. Se você não
fornecer um assunto na linha de comando, darcs criará um com base nos nomes dos
patches no pacote de patches.

Use o sinalizador `--in-reply-to` para definir os cabeçalhos In-Reply-To e References do
e-mail a ser enviado. Por padrão, nenhum cabeçalho adicional é incluído, então o e-mail não será
tratada como resposta por leitores de correio.

Se você quiser incluir uma descrição ou explicação junto com o pacote de patches,
você precisa especificar o sinalizador `--edit-description`, que fará com que o darcs abra
um editor com o qual você pode escrever uma mensagem para acompanhar seus patches.

Se você quiser usar um comando diferente do padrão para enviar e-mail, você
precisa especificar uma linha de comando com a opção `--sendmail-command`. A linha de comando
pode conter alguns especificadores de formato que são substituídos pelos valores reais. Aceitaram
especificadores de formato são `% s` para assunto,`% t` para, `% c` para cc,`% b` para o corpo de
o e-mail, `% f` para de,`% a` para o pacote de patch e os mesmos especificadores em
maiúsculas para os valores codificados por URL. Além disso, você pode adicionar `% <` ao final do
linha de comando se o comando espera a mensagem de e-mail completa na entrada padrão. Por exemplo
as linhas de comando para evolução e msmtp são assim:

evolução "mailto:% T? subject =% S & attach =% A & cc =% C & body =% B"
msmtp -t%

Não confunda as opções `--author` com o endereço de retorno que` darcs send` irá
definido para seu pacote de patch.

Por exemplo, se você tiver dois endereços de e-mail A e B:

* Se você usa `--author A`, mas sua máquina está configurada para enviar e-mail de
endereço B por padrão, o endereço de retorno em sua mensagem será B. * Se você
use `--from A` e seu cliente de e-mail suporta a configuração do
De: endereço arbitrariamente (alguns clientes de e-mail não semelhantes ao Unix, especialmente,
pode não suportar isso), o endereço de retorno será A; se isso acontecer
não suportar isso, o endereço de retorno será B. * Se você não fornecer nenhum
`--from` nem` --author` então o retorno
o endereço será B.

Além disso, a menos que você especifique o comando sendmail com `--sendmail-command`, darcs
envia e-mail usando o comando de e-mail padrão em seu computador. Este comando padrão é
determinado pelo script `configure`. Assim, em alguns sistemas operacionais não semelhantes ao Unix, `--from` é
provavelmente não funcionará.

dardos Aplique <arquivo de patch>
O comando `darcs apply` pega um pacote de patch e tenta inseri-lo no
repositório atual. Além de invocá-lo diretamente em pacotes criados por `darcs
send`, é usado internamente por `darcs push` na extremidade remota de uma conexão SSH.

Se nenhum arquivo for fornecido, o pacote é lido da entrada padrão.

Se receber um e-mail em vez de um pacote de patch, Darcs irá procurar o pacote como um MIME
anexo a esse e-mail. Atualmente, isso irá falhar se o limite MIME for reescrito,
como em Courier e Mail.app.

Se o `--resposta [email protegido]opção `é usada, e o pacote é anexado a um
e-mail, Darcs irá enviar um relatório (indicando sucesso ou falha) ao remetente do
pacote (o campo `Para`). O argumento para noreply é o endereço que o relatório irá
parecem se originar DE.

A opção `--cc` fará com que o relatório seja copiado para outro endereço, por exemplo
`--cc [email protegido],[email protegido]`. Usando `--cc` sem
`--reply` é indefinido.

Se você quiser usar um comando diferente do padrão para enviar e-mails, você precisa
para especificar uma linha de comando com a opção `--sendmail-command`. A linha de comando pode
contém o especificador de formato `% t` para e você pode adicionar`% <`ao final do
linha de comando se o comando espera o e-mail completo na entrada padrão. Por exemplo,
a linha de comando para msmtp se parece com isto:

msmtp -t%

If gpg(1) estiver instalado, você pode usar `--verify pubring.gpg` para rejeitar pacotes que
não são assinados por uma chave em `pubring.gpg`.

Se `--test` for fornecido e um teste for definido (veja` darcs setpref`), o pacote irá
ser rejeitado se o teste falhar após aplicá-lo. Nesse caso, o e-mail de rejeição
from `--reply` incluirá a saída do teste.

Um pacote de patch pode introduzir conflitos não resolvidos com patches existentes ou com o
árvore de trabalho. Por padrão, Darcs irá adicionar marcadores de conflito (veja `darcs
conflitos de marcas »).

A opção `--external-merge` permite que você resolva esses conflitos usando uma fusão externa
ferramenta. Na opção, `% a` é substituído pelo ancestral comum (base de fusão),`% 1`
com a primeira versão, `% 2` com a segunda versão e`% o` com o caminho onde
seu conteúdo resolvido deve ir. Por exemplo, para usar a ferramenta de mesclagem visual xxdiff
você especificaria: `--external-merge = 'xxdiff -m -O -M% o% 1% a% 2'`

A opção `--allow-concepts` irá pular a marcação de conflitos; isso é útil quando você
deseja tratar um repositório como apenas um monte de patches, como o uso de `darcs pull
--union` para baixar os patches de seus colegas de trabalho antes de ficar offline.

Isso pode bagunçar mudanças não registradas na árvore de trabalho, forçando você a resolver o
conflito imediatamente. Para simplesmente rejeitar pacotes que introduzem conflitos não resolvidos,
usando a opção `--dont-allow-concepts`. Tornando este o padrão em push-based
fluxos de trabalho são fortemente recomendados.

Ao contrário da maioria dos comandos Darcs, o padrão `darcs apply` é` --all`. Use o
opção `--interactive` para escolher quais patches aplicar de um pacote.

dardos clonar <repositório> [anuário>]
Clone cria uma cópia de um repositório. O segundo argumento opcional especifica um
diretório de destino para a nova cópia; se omitido, é inferido da fonte
localização.

Por padrão, o Darcs irá copiar todos os patches do repositório original. Isso significa que
a cópia é totalmente independente do original; você pode operar no novo repositório
mesmo quando o original está inacessível. Se você espera que o repositório original
permanecer acessível, você pode usar `--lazy` para evitar a cópia de patches até que sejam necessários
(`cópia sob demanda '). Isso é particularmente útil ao copiar um repositório remoto com
uma longa história com a qual você não se importa.

Ao clonar localmente, o Darcs usa automaticamente hard linking sempre que possível. Também
como economia de tempo e espaço, isso permite mover ou excluir o repositório original
sem afetar a cópia. O hard linking requer que a cópia esteja no mesmo
sistema de arquivos como o repositório original e que o sistema de arquivos suporte hard linking.
Isso inclui NTFS, HFS + e todos os sistemas de arquivos Unix de uso geral (como ext, UFS
e ZFS). FAT não oferece suporte a links físicos.

Ao clonar de um local remoto, Darcs procurará e tentará usar pacotes
criado por `darcs otimizar http` no repositório remoto. Os pacotes são arquivos grandes únicos
que pode ser baixado em vez de muitos pequenos arquivos, o que torna a clonagem mais rápida
http.

O clone do Darcs não copiará as alterações não registradas para a árvore de trabalho do repositório de origem.

Você pode copiar um repositório para uma url ssh, caso em que o novo repositório sempre
seja completo.

Freqüentemente, é desejável fazer uma cópia de um repositório que exclui alguns patches. Por
exemplo, se os lançamentos são marcados, então `darcs clone --tag .` faria uma cópia do
repositório na versão mais recente.

Um estado de repositório não marcado ainda pode ser identificado sem ambigüidade por um arquivo de contexto,
conforme gerado por `darcs log --context`. Dado o nome de tal arquivo, o `--context`
opção criará um repositório que inclui apenas os patches desse contexto.
Quando um usuário relata um bug em uma versão não lançada de seu projeto, o recomendado
maneira de descobrir exatamente qual versão eles estavam executando é fazer com que incluam um
arquivo de contexto no relatório de bug.

Você também pode fazer uma cópia de um estado não marcado usando `--to-patch` ou` --to-match`
opções, que excluem patches * após * o primeiro patch correspondente. Porque estes
opções tratam o conjunto de patches como uma sequência ordenada, você pode obter resultados diferentes
após reordenar com `darcs optimize`, então a marcação é preferível.

A opção `--set-scripts-executable` faz com que os scripts se tornem executáveis ​​no
árvore de trabalho. Um script é qualquer arquivo que comece com um shebang ("#!").

Administrando repositórios:
dardos inicializar [<anuário>]
O comando `darcs initialize` transforma o diretório atual em um repositório Darcs.
Quaisquer arquivos e subdiretórios existentes tornam-se alterações NÃO SALVAS: registre-os com `darcs
registro --look-for-adds`.

Este comando cria o diretório `_darcs`, que armazena metadados de controle de versão.
Ele também contém configurações por repositório em `_darcs / prefs /`, sobre as quais você pode ler
no manual do usuário.

Por padrão, os patches do novo repositório estão na semântica darcs-2. No entanto é
possível criar um repositório na semântica darcs-1 com a bandeira `--darcs-1`,
embora isso não seja recomendado, exceto para compartilhar patches com um projeto que usa
patches na semântica darcs-1.

Inicializar é comumente abreviado para `init`.

dardos otimizar limpar
Este comando exclui arquivos obsoletos do repositório.
dardos otimizar http
Usar esta opção cria 'pacotes de repositório' que podem acelerar drasticamente
desempenho quando um usuário faz um `darcs clone` do repositório sobre HTTP. Para fazer uso
de packs, os clientes devem ter um darcs de pelo menos versão 2.10.

dardos otimizar reordenar
Este comando move os patches recentes (aqueles não incluídos na última tag) para o
"front", reduzindo a quantidade de download de um comando remoto típico. Isto
também deve reduzir o tempo de CPU necessário para algumas operações.
dardos otimizar ativar-patch-index
Crie o índice de patch, uma estrutura de dados interna que acelera os comandos que precisam
para saber quais patches tocam em um determinado arquivo. Como anotar e registrar.
dardos otimizar desativar-patch-index
Exclua e pare de manter o índice de patch do repositório.
dardos otimizar comprimir
Por padrão, os patches são compactados com zlib (RFC 1951) para reduzir o armazenamento (e
download). Em circunstâncias excepcionais, pode ser preferível evitar
compressão. Neste caso, a opção `--dont-compress` pode ser usada (por exemplo, com` darcs
record`) para evitar compressão.

Os comandos `darcs optimize uncompress` e` darcs optimize compress` podem ser usados ​​para
garantir que os patches existentes no repositório atual sejam respectivamente descompactados ou
comprimido.
dardos otimizar descomprimir
Por padrão, os patches são compactados com zlib (RFC 1951) para reduzir o armazenamento (e
download). Em circunstâncias excepcionais, pode ser preferível evitar
compressão. Neste caso, a opção `--dont-compress` pode ser usada (por exemplo, com` darcs
record`) para evitar compressão.

Os comandos `darcs optimize uncompress` e` darcs optimize compress` podem ser usados ​​para
garantir que os patches existentes no repositório atual sejam respectivamente descompactados ou
comprimido.
dardos otimizar religar
O comando `darcs Optimize relink` liga os patches que o repositório atual possui
em comum com seus pares. Peers são os repositórios listados em
`_darcs / prefs / sources`, ou definido com a opção` --sibling` (que pode ser usada
várias vezes).

O Darcs usa links físicos automaticamente, portanto, esse comando raramente é necessário. É muito
útil se você usou `cp -r` em vez de` darcs clone` para copiar um repositório, ou se você
puxou o mesmo patch de um repositório remoto para vários repositórios locais.
dardos otimizar intocada
Este comando atualiza o formato de `_darcs / pristine.hashed /`, que era diferente
antes de darcs 2.3.1.
dardos otimizar atualização
Converta repositórios antigos para o formato hash padrão atual.
dardos otimizar esconderijo <anuário> ...
Este comando exclui arquivos obsoletos do cache global. Leva um ou mais
diretórios como argumentos e pesquisa recursivamente todos os repositórios dentro desses
diretórios. Em seguida, ele exclui todos os arquivos do cache global que não pertencem a esses
repositórios. Quando nenhum diretório é fornecido, ele pesquisa repositórios na casa do usuário
diretório.

Ele também migra automaticamente o cache global para o formato de bucket (padrão).

dardos reparar
O comando `darcs repair` tenta corrigir a corrupção no repositório atual.
Atualmente, ele só pode reparar danos à árvore intocada, que é onde a maioria
corrupção ocorre. Este comando reconstrói uma árvore primitiva, aplicando sucessivamente o
patches no repositório para uma árvore vazia.

A sinalização `--dry-run` torna esta operação somente leitura, fazendo com que darcs saia sem sucesso
(com um status de saída diferente de zero) se o pristine reconstruído for diferente do atual
intocada.

dardos converter darcs-2 <fonte> [destino>]
Este comando converte um repositório que usa a semântica de patch antiga `darcs-1` em um
novo repositório com a semântica `darcs-2` atual.

AVISO: o repositório produzido por este comando não é compreendido por Darcs 1.x, e
patches não podem ser trocados entre repositórios nos formatos darcs-1 e darcs-2.

Além disso, os repositórios criados por diferentes invocações deste comando NÃO DEVEM
trocar patches.

dardos converter exportar
Este comando permite exportar repositórios darcs para git.

Para uma exportação única, você pode usar a receita:

$ cd repositório
$ git init../espelho
$ darcs convert export export | (cd ../mirror && git fast-import)

Para exportação incremental usando markfiles:

$ cd repositório
$ git init../espelho
$ toque ../mirror/git.marks
$ darcs converter exportação --read-marks darcs.marks --write-marks darcs.marks
| (cd ../mirror && git fast-import --import-marks = git.marks
--export-marks = git.marks)

No caso de exportação incremental, tome cuidado para nunca alterar, excluir ou reordenar
patches no repositório darcs de origem.

Além disso, esteja ciente de que exportar um repositório darcs para git não será exatamente fiel em
termos da história se o repositório darcs contiver conflitos.

Limitações:

* Diretórios vazios não são suportados pelo protocolo de exportação rápida. * Unicode
nomes de arquivos atualmente não são tratados corretamente.
See http://bugs.darcs.net/issue2359 .

dardos converter importar [<anuário>]
Este comando importa repositórios git para novos repositórios darcs. Mais opções
são aceitos (veja `darcs help init`).

Para converter um repositório git em um novo darcs, você pode executar:
$ (cd gitrepo && git fast-export --todos) | darcs convert import darcsmirror

AVISO: repositórios git com branches irão produzir resultados estranhos,
use por sua própria conta e risco.

A importação incremental com markfiles não é atualmente suportada.

dardos rebase puxar [repositório] ...
Copie e aplique patches de outro repositório, suspendendo todos os patches locais que
conflito.
dardos rebase Aplique <arquivo de patch>
Aplique um pacote de patch, suspendendo todos os patches locais que estejam em conflito.
dardos rebase suspender
Selecione os patches para mover para um estado suspenso no final do repo.

dardos rebase retirar da suspensão
Patches selecionados para restaurar de um estado suspenso até o final do repo.

dardos rebase obliterar
Elimine um patch que está suspenso.

dardos rebase log
Liste as alterações suspensas no momento.

MEIO AMBIENTE

EMPRESA e DADOS DO APLICATIVO
As preferências por usuário são definidas em $ HOME / .darcs (no Unix) ou% APPDATA% / darcs (no Windows).
Este também é o local padrão do cache.

DARCS_EDITOR, DARCSEDITOR, VISUAL e EDITOR
Para editar uma descrição de patch de comentário de e-mail, Darcs irá invocar um editor externo. Sua
editor preferido pode ser definido como qualquer uma das variáveis ​​de ambiente $ DARCS_EDITOR,
$ DARCSEDITOR, $ VISUAL ou $ EDITOR. Se nenhum desses for definido, editor(1) é usado.

DARCS_PAGER e PAGER
Darcs às vezes invocará um pager se julgar que a saída é muito longa para caber na tela.
Darcs usará o pager especificado por $ DARCS_PAGER ou $ PAGER. Se nenhum estiver definido,
pager(1) será usado.

DARCS_DONT_COLOR, DARCS_ALWAYS_COLOR, DARCS_ALTERNATIVE_COLOR e DARCS_DO_COLOR_LINES
Se o terminal entender sequências de escape de cor ANSI, darcs destacará certas
palavras-chave e delimitadores ao imprimir patches. Isso pode ser desligado definindo o
variável de ambiente DARCS_DONT_COLOR para 1. Se você usar um pager que por acaso entender
Cores ANSI, como `less -R`, darcs podem ser forçados sempre a destacar a saída configurando
DARCS_ALWAYS_COLOR para 1. Se você não pode ver as cores, você pode definir DARCS_ALTERNATIVE_COLOR para 1,
e darcs usará códigos ANSI para vídeo em negrito e reverso em vez de cores. Além disso,
há um modo extra-colorido, que não é habilitado por padrão, que pode ser ativado
com DARCS_DO_COLOR_LINES

DARCS_DONT_ESCAPE_TRAILING_SPACES e DARCS_DONT_ESCAPE_TRAILING_CR
Por padrão, os darcs irão escapar (destacando se possível) de qualquer tipo de espaço no final
de linhas ao mostrar o conteúdo do patch. Se você não quiser, pode desligá-lo
definindo DARCS_DONT_ESCAPE_TRAILING_SPACES para 1. Um caso especial existe apenas para carro
retorna: DARCS_DONT_ESCAPE_TRAILING_CR

DARCS_DONT_ESCAPE_ANYTHING, DARCS_DONT_ESCAPE_ISPRINT, DARCS_DONT_ESCAPE_8BIT,
DARCS_DONT_ESCAPE_EXTRA e DARCS_ESCAPE_EXTRA
O Darcs precisa escapar certos caracteres ao imprimir o conteúdo do patch em um terminal.
Caracteres como backspace podem esconder o conteúdo do patch do usuário, e outros
sequências de caracteres podem até mesmo em alguns casos redirecionar comandos para o shell se o terminal
permite isso.

Por padrão, o darcs só permite caracteres ASCII de 7 bits imprimíveis (incluindo espaço), e
os dois caracteres de controle tab e nova linha. Todos os outros octetos são impressos na forma entre aspas
(como `^ `ou` \ `).

Darcs tem suporte limitado para localidades. Se a localidade do sistema for um byte único
codificação de caracteres, como as codificações latinas, você pode definir a variável de ambiente
DARCS_DONT_ESCAPE_ISPRINT para 1 e darcs irá exibir todos os imprimíveis no atual
localidade do sistema em vez de apenas os ASCII. NOTA: Isso atualmente não funciona em alguns
arquiteturas se darcs for compilado com GHC 6.4 ou posterior. Algum controle não ASCII
os caracteres podem ser impressos e podem falsificar o terminal.

Para codificações de caracteres multibyte, as coisas são menos suaves. UTF-8 funcionará se você definir
DARCS_DONT_ESCAPE_8BIT para 1, mas não imprimíveis fora do intervalo ASCII de 7 bits não são
já escapou. Por exemplo, os caracteres de controle extras do Latin-1 podem deixar seu terminal
à mercê do conteúdo do adesivo. Caracteres de espaço fora do intervalo ASCII de 7 bits não são
mais reconhecido e não terá escape adequado nas terminações de linha.

Como último recurso, você pode definir DARCS_DONT_ESCAPE_ANYTHING para 1. Então, tudo o que não
Os conjuntos de código flip devem funcionar, assim como todos os recursos do seu terminal. Isto
variável de ambiente também pode ser útil se você canalizar a saída para um pager ou externo
filtro que sabe melhor do que darcs como lidar com sua codificação. Observe que todos os escapes,
incluindo o escape especial de quaisquer espaços de final de linha, será desativado por este
criação.

Existem duas variáveis ​​de ambiente que você pode definir para dizer explicitamente aos darcs para não escapar ou
octetos de escape. Eles são DARCS_DONT_ESCAPE_EXTRA e DARCS_ESCAPE_EXTRA. Seus valores
devem ser strings consistindo nos octetos textuais em questão. As fugas levam
precedência sobre os não-escapes. Caracteres de espaço ainda são escapados nas terminações de linha
no entanto. A variável de ambiente especial DARCS_DONT_ESCAPE_TRAILING_CR desativa o escape
de retorno de carro por último na linha (estilo DOS).

DARCS_TMPDIR e TMPDIR
Darcs freqüentemente cria diretórios temporários. Por exemplo, o comando `darcs diff` cria
dois para que as árvores de trabalho sejam analisadas. Por padrão, diretórios temporários são criados em
/ Tmp, ou se não existir, em _darcs (dentro do repositório atual). Isso pode ser
substituído especificando algum outro diretório no arquivo _darcs / prefs / tmpdir ou o
variável de ambiente $ DARCS_TMPDIR ou $ TMPDIR.

DARCS_KEEP_TMPDIR
Se a variável de ambiente DARCS_KEEP_TMPDIR for definida, darcs não removerá o
diretórios temporários que ele cria. Isso se destina principalmente à depuração do próprio Darcs,
mas também pode ser útil, por exemplo, para determinar porque sua preferência de teste (veja `darcs
setpref`) está falhando quando você executa o `darcs record`, mas funciona quando executado manualmente.

DARCS_EMAIL e EMAIL
Cada patch é atribuído ao seu autor, geralmente por endereço de e-mail (por exemplo, `Fred
Bloggs[email protegido]> `). Darcs procura em vários lugares por esta string de autor: o
opção `--author`, os arquivos` _darcs / prefs / author` (no repositório) e
`~ / .darcs / autor`(em seu diretório inicial), e as variáveis ​​de ambiente` $ DARCS_EMAIL`
e `$ EMAIL`. Se nenhum deles existir, Darcs irá solicitar uma string de autor e
escreva para `~ / .darcs / autor`. Observe que se você tiver mais de um endereço de e-mail, você pode
colocá-los todos em `~ / .darcs / autor`, um autor por linha. Darcs ainda irá solicitar a você
um autor, mas permite que você selecione na lista ou digite uma alternativa.

ENVIAR CORREIO
No Unix, o comando `darcs send` depende de enviar correio(8). O `--sendmail-command` ou
A variável de ambiente $ SENDMAIL pode ser usada para fornecer um caminho explícito para este programa;
caso contrário, os locais padrão / usr / sbin / sendmail e / usr / lib / sendmail será tentado.

DARCS_SLOPPY_LOCKS
Se em alguns sistemas de arquivos você receber um erro do tipo:

darcs: takeLock [...]: atomic_create [...]: operação não suportada

você pode querer tentar exportar DARCS_SLOPPY_LOCKS = True.

DARCS_SSH
Repositórios da forma [user @] host: [dir] são considerados repositórios remotos, que
Darcs acessa com o programa externo ssh(1).

A variável de ambiente $ DARCS_SSH pode ser usada para especificar um cliente SSH alternativo.
Os argumentos podem ser incluídos, separados por espaços em branco. O valor não é interpretado por um
shell, portanto, as construções de shell não podem ser usadas; em particular, não é possível para o
nome do programa para conter espaços em branco usando aspas ou escape.

DARCS_SCP e DARCS_SFTP
Ao ler de um repositório remoto, Darcs tentará executar `darcs transfer-mode` em
o host remoto. Isso irá falhar se o host remoto tiver apenas Darcs 1 instalado, não
tenha o Darcs instalado ou permite apenas SFTP.

Se o modo de transferência falhar, Darcs recorrerá scp(1) e Sftp(1). Os comandos invocados
pode ser personalizado com as variáveis ​​de ambiente $ DARCS_SCP e $ DARCS_SFTP respectivamente,
que se comportam como $ DARCS_SSH. Se a extremidade remota permitir apenas sftp, tente definir
DARCS_SCP = sftp.

SSH_PORT
Se esta variável de ambiente for definida, ela será usada como o número da porta para todas as chamadas SSH
feito por Darcs (ao acessar repositórios remotos sobre SSH). Isso é útil se o seu SSH
servidor não funciona na porta padrão e seu cliente SSH não suporta
ssh_config(5). Os usuários do OpenSSH provavelmente preferirão colocar algo como `Host
* .example.net Porta 443` em seu ~ / .ssh / config arquivo.

PROXY HTTP, HTTPS_PROXY, FTP_PROXY, ALL_PROXY e NO_PROXY
Se o Darcs foi construído com libcurl, as variáveis ​​de ambiente HTTP_PROXY, HTTPS_PROXY e
FTP_PROXY pode ser definido como a URL de um proxy no formulário

[protocolo://] [:porta]

Nesse caso, libcurl usará o proxy para o protocolo associado (HTTP, HTTPS e
FTP). A variável de ambiente ALL_PROXY pode ser usada para definir um único proxy para todos os libcurl
pedidos.

Se a variável de ambiente NO_PROXY for uma lista separada por vírgulas de nomes de host, o acesso a
esses hosts irão ignorar proxies definidos pelas variáveis ​​acima. Por exemplo, é bastante
comum para evitar solicitações de proxy para máquinas na rede local com

NO_PROXY = localhost, *. Localdomain

Para compatibilidade com lynx et al, equivalentes em minúsculas dessas variáveis ​​de ambiente
(por exemplo, $ http_proxy) também são compreendidos e são usados ​​preferencialmente em maiúsculas
versões.

Se o Darcs não foi construído com libcurl, todas essas variáveis ​​de ambiente são silenciosamente ignoradas,
e não há como usar um proxy da web.

DARCS_PROXYUSERPWD
Se o Darcs foi construído com libcurl, e você está usando um proxy da web que requer
autenticação, você pode definir a variável de ambiente $ DARCS_PROXYUSERPWD para o nome de usuário
e a senha esperada pelo proxy, separadas por dois pontos. Esta variável de ambiente é
ignorado silenciosamente se o Darcs não foi construído com libcurl.

DARCS_GET_FOO e DARCS_APPLY_FOO
Ao tentar acessar um repositório com uma URL começando com foo: //, darcs irá invocar o
programa especificado pela variável de ambiente DARCS_GET_FOO (se definido) para baixar cada
arquivo e o comando especificado pela variável de ambiente DARCS_APPLY_FOO (se definido)
ao enviar para um foo: // URL.

Este método sobrescreve todas as outras maneiras de obter URLs `foo: // xxx`.

Observe que cada comando deve ser construído de modo que envie o conteúdo baixado para
STDOUT, e o próximo argumento para ele deve ser o URL. Aqui estão alguns exemplos que devem
trabalhar para DARCS_GET_HTTP:

buscar -q -o -
enrolar -s -f
fonte do lince
wget -q -O -

Além desses exemplos de brinquedos, é provável que você precise manipular o argumento
antes de passá-lo para o programa de busca real. Por exemplo, considere o problema de
obter acesso de leitura a um repositório em um compartilhamento CIFS (SMB) sem privilégios de montagem:

export DARCS_GET_SMB ​​= 'smbclient -c get'
darcs get smb: // fs / twb / Desktop / hello-world

O comando acima não funcionará por vários motivos. Em primeiro lugar, Darcs vai passar um
argumento começando com `smb:`, que smbclient não entende. Em segundo lugar, o hospedeiro
e compartilhar `// fs / twb` deve ser apresentado como um argumento separado para o caminho
`Desktop / hello-world`. Em terceiro lugar, smbclient requer que `get` e o caminho sejam um único
argumento (incluindo um espaço), em vez de dois argumentos separados. Finalmente, smbclient's
O comando `get` grava o arquivo no disco, enquanto Darcs espera que ele seja impresso de acordo com o padrão
saída.

Em princípio, poderíamos contornar esses problemas fazendo com que a variável contivesse um shell
script, infelizmente, Darcs divide o comando em espaços em branco e não entende
citação ou escape. Portanto, em vez disso, precisamos colocar os comandos em separado, executáveis
scripts.

Continuando nosso exemplo smbclient, criamos um script executável
`~ / .darcs / libexec / get_smb`com o seguinte conteúdo:

#!/ bin / bash -e
IFS = / ler arquivo de compartilhamento de host <<< '$ {1 # smb: //}'
smbclient // $ host / $ share -c 'get $ file -'

E finalmente podemos dizer

exportar DARCS_GET_SMB ​​=~ / .darcs / libexec / get_smb
darcs get smb: // fs / twb / Desktop / hello-world

O comando APPLY será chamado com um patchfile darcs canalizado em sua entrada padrão.

DARCS_CONNECTION_TIMEOUT
Defina o tempo máximo em segundos que o darcs permite e a conexão deve durar. Se a variável
não for especificado, o padrão é 30 segundos. Esta opção funciona apenas com curl.

Use darcs online usando serviços onworks.net