maneira de gerar diferenças entre dois arquivos (de preferência usando a linha de comando)
<p>estou familiarizado com ferramentas como tkdiff e winmerge e estou ciente de como ver a diferença entre dois arquivos.</p><p>o que estou procurando fazer é produzir um relatório de elementos em um arquivo que não estão presentes em outro.</p><p>por exemplo:</p><p>o arquivo1 contém:</p><pre><code>apple cool dude flan </code></pre><p>o arquivo2 contém:</p><pre><code>apple ball cool dude elephant </code></pre><p>quero produzir um relatório que contenha:</p><pre><code>ball elephant </code></pre><p>ou, melhor ainda, um relatório como este:</p><pre><code>+ball +elephant -flan </code></pre><p>alguém sabe de uma ferramenta que pode fazer isso? de preferência com opções de linha de comando.</p><p>o recurso de relatório no winmerge não está muito longe do que eu gostaria, mas não há opção de linha de comando para fazer isso (tanto quanto eu sei).</p><p>desde já, obrigado.</p>
<p>você provavelmente deseja o <a href="http://man7.org/linux/man-pages/man1/comm.1.html">tilitário de comunicação unix</a> . <a href="http://gnuwin32.sourceforge.net/packages/coreutils.htm">versões do windows</a> estão incluídas no gnuwin32</p><blockquote> <p>nome</p> <pre><code> comm - compare two sorted files line by line </code></pre> <p>sinopse</p> <pre><code> comm [option]... file1 file2 </code></pre> <p>descrição</p> <pre><code> compare sorted files file1 and file2 line by line. with no options, produce three-column output. column one contains lines unique to file1, column two contains lines unique to file2, and column three contains lines common to both files. -1 suppress lines unique to file1 -2 suppress lines unique to file2 -3 suppress lines that appear in both files </code></pre></blockquote>
<p><strong> para uma lista de arquivos a serem empurrados, execute: </strong></p><pre><code>git diff --stat --cached [remote/branch] </code></pre><p><em> exemplo: </em></p><pre><code>git diff --stat --cached origin/master </code></pre><p><strong> para o diff do código dos arquivos a serem enviados, execute: </strong></p><pre><code>git diff [remote repo/branch] </code></pre><p><strong> para ver os caminhos completos dos arquivos que serão alterados, execute: </strong></p><pre><code>git diff --numstat [remote repo/branch] </code></pre><p>se você quiser ver estes diffs em uma gui, você precisará configurar o git para isso. veja <a href="https://stackoverflow.com/questions/255202/how-do-i-view-git-diff-output-with-visual-diff-program">como vejo a saída 'git diff' com um programa de diferenças visuais?</a> .</p> <p>tente <a href="http://macupdate.com">macupdate</a> , <a href="http://mac.softpedia.com/">softpedia</a> e <a href="http://mac.brothersoft.com">brothersoft</a> . procure por merge folder.</p><h3> <a href="http://mac.softpedia.com/get/system-utilities/folder-merge.shtml">pasta mesclada</a> </h3><blockquote> <p>utilitário de software pequeno que mesclará o conteúdo da pasta</p> <p>por padrão, o osx não mescla o conteúdo da pasta, portanto, essa é uma ferramenta gráfica simples para fazer exatamente isso.</p> <p>se você simplesmente quiser mesclar os arquivos localizados em duas pastas separadas, poderá fazer isso facilmente com a mesclagem de pastas.</p> </blockquote><hr><h3> <a href="http://alan.petitepomme.net/unison/index.html">níssono</a> </h3><p>isso é de graça.</p><blockquote> <p>unison é uma ferramenta de sincronização de arquivos para unix e windows. ele permite que duas réplicas de uma coleção de arquivos e diretórios sejam armazenadas em diferentes hosts (ou discos diferentes no mesmo host), modificadas separadamente e, depois, atualizadas pela propagação das alterações em cada réplica para a outra.</p> </blockquote> <p>se você estiver interessado no código de erro, é uma maneira mais portátil de obtê-lo, em vez de dividir por 256:</p><pre><code>printf("exit code: %i\n", wexitstatus(pclose(fp))); </code></pre><p>no entanto, <code>popen</code> é uma maneira, então você está criando outras soluções alternativas pelo estilo de redirecionamento usual no shell ou segue este código não testado para fazer o certo:</p><pre><code>#include &lt;unistd.h&gt; #include &lt;stdio.h&gt; /* since pipes are unidirectional, we need two pipes. one for data to flow from parent's stdout to child's stdin and the other for child's stdout to flow to parent's stdin */ #define num\_pipes 2 #define parent\_write\_pipe 0 #define parent\_read\_pipe 1 int pipes[num\_pipes][2]; /* always in a pipe[], pipe[0] is for read and pipe[1] is for write */ #define read\_fd 0 #define write\_fd 1 #define parent\_read\_fd ( pipes[parent\_read\_pipe][read\_fd] ) #define parent\_write\_fd ( pipes[parent\_write\_pipe][write\_fd] ) #define child\_read\_fd ( pipes[parent\_write\_pipe][read\_fd] ) #define child\_write\_fd ( pipes[parent\_read\_pipe][write\_fd] ) void main() { int outfd[2]; int infd[2]; // pipes for parent to write and read pipe(pipes[parent\_read\_pipe]); pipe(pipes[parent\_write\_pipe]); if(!fork()) { char *argv[]={ "/usr/bin/bc", "-q", 0}; dup2(child\_read\_fd, stdin\_fileno); dup2(child\_write\_fd, stdout\_fileno); /* close fds not required by child. also, we don't want the exec'ed program to know these existed */ close(child\_read\_fd); close(child\_write\_fd); close(parent\_read\_fd); close(parent\_write\_fd); execv(argv[0], argv); } else { char buffer[100]; int count; /* close fds not required by parent */ close(child\_read\_fd); close(child\_write\_fd); // write to child’s stdin write(parent\_write\_fd, "2^32\n", 5); // read from child’s stdout count = read(parent\_read\_fd, buffer, sizeof(buffer)-1); if (count &gt;= 0) { buffer[count] = 0; printf("%s", buffer); } else { printf("io error\n"); } } } </code></pre><p>o código é daqui:</p><p> <a href="http://jineshkj.wordpress.com/2006/12/22/how-to-capture-stdin-stdout-and-stderr-of-child-program/">http://jineshkj.wordpress.com/2006/12/22/how-to-capture-stdin-stdout-and-stderr-of-child-program/</a> </p> <p>uma pequena nota é que você poderia usar as duas vezes para fazer o comando não mover os dados (assumindo que os dois caminhos estejam no mesmo sistema de arquivos).</p><pre><code>ln /some/path/file /another/path/ &amp;&amp; ln -sf /another/path/file /some/path/ </code></pre><p>mas eu suponho que você deseja mover o conteúdo de/alguns/path/para um outro disco e, em seguida, criar links para os novos arquivos de modo "ninguém".</p><pre><code>for f in `ls /some/path/`; do ln /some/path/$f /another/path/ &amp;&amp; ln -sf /another/path/$f /some/path; done </code></pre><p>envolvendo-o em uma função bash:</p><pre><code>function cpln { for f in `ls $1` do ln $1/$f $2 &amp;&amp; ln -sf $2/$f $1 done } </code></pre> no começo do arquivo .patch tem o caminho esperado do arquivo que será alterado. nesse caso é esperado que vc esteja na raiz de onde extraiu o kernel. daí é mandar aplicar executar o comando informando o arquivo .patch.

por exemplo, vc extraiu o código fonte em /home/thiago/downloads/linux-5.10.9

… <p>sempre use <code>rsync</code> para copiar arquivos, porque é ótimo.</p><p>para ignorar arquivos existentes:</p><pre><code>rsync --ignore-existing --recursive /src /dst </code></pre><p>leia o <a href="http://linux.die.net/man/1/rsync">manual</a> e pesquise muitos exemplos excelentes. especialmente a combinação com o ssh faz com que <code>rsync</code> seja uma ótima ferramenta para conexões lentas e não confiáveis, devido à sua <code>--partial</code> opção. adicionar <code>--verbose</code> para ver quais arquivos estão sendo copiados. verifique também a infinidade de opções relacionadas à preservação de permissões, usuários e registros de data e hora.</p> lembre que somente quem tem permissão no arquivo ou diretório poderá alterar as permissões, quando ocorrer erros, verifique seus direitos sobre o arquivo ou diretório com o comando "ls -l" ou faça com poderes de root. 

tendo em mente que o conceito de binário significa 0 = desligado e 1 = ligado, vejamos como fica na tabela abaixo:


 rwx
 0 - 000
 1 - 001
 2 - 010
 3 - 011
 4 - 100
 5 - 101
 6 - 110
 7 - 111



onde "rwx" são as permissões de um arquivo, ou seja:


 r=read (leitura)
 w=write (gravação, alteração, deleção)
 x=execute (execução)



feito isso, sabemos que um arquivo ou diretório possui 3 modos de permissão. uma permissão para o dono do arquivo ou seja, quem o criou, uma outra permissão para o grupo do usuário dono do arquivo, e outra permissão para qualquer outro usuário ou grupo. 

sabendo disso, temos a tabela final abaixo:


 dono grupo outros
 rwx rwx rwx
 0 - 000 000 000
 1 - 001 001 001
 2 - 010 010 010
 3 - 011 011 011
 4 - 100 100 100
 5 - 101 101 101
 6 - 110 110 110
 7 - 111 111 111



exemplo: temos um diretório qualquer chamado mp3 que eu quero permissão total para o dono [eu], permissão de apenas leitura para o meu grupo e nenhuma permissão para o resto do mundo. o comando para executar essa ação é o chmod (em minúsculo mesmo). 

$ chmod 740 /mp3 <p><code>logrotate</code> foi uma boa ideia.</p><p>como qualquer arquivo regular, wtmp poderia ser "esparso" (cf. lseek (2) "buracos" e <code>ls -s</code>) que pode mostrar um tamanho de arquivo extremo que realmente ocupa pouco disco. como o buraco foi parar lá, se era um buraco? <code>getty(8)</code> e amigos podem ter tido um bug. ou uma falha do sistema e reparo do fsck podem ter causado isso.</p><p>se você está procurando ver o conteúdo bruto de wtmp, <code>od</code> ou <code>hd</code> são bons para dar uma olhada nos binários e têm o feliz efeito colateral de mostrar longas execuções de vazio como tal.</p><p>a menos que ocorra novamente, eu não pensaria muito mais nisso. um intruso marginalmente competente faria um trabalho melhor do que isso, os conteúdos não são tão interessantes e pouco depende deles.</p> <p>se bem entendi, você deseja enviar dados para um programa em execução dentro de uma sessão de tela. você pode fazer isso com o comando <code>stuff</code> da tela. use a tela <code>-x</code> opção para executar um comando em uma sessão de tela sem anexar a ela.</p><pre><code>screen -s sessionname -p windowname -x stuff 'command1 command2 ' </code></pre><p>se você quiser ver a saída do programa, consulte os comandos <code>hardcopy</code>, <code>log</code> e <code>logfile</code>.</p> <p>fala aí joaquim, tudo bem? sim, é possível você criar um componente para lidar com formulários, mas, ele vai exigir uma complexidade maior.</p>
<p>o ideal é a gente ter ambos, tanto o <code>form</code> quanto o <code>input</code> ser componentes separados.</p>
<p>mas, hoje em dia já temos bastante bibliotecas para lidar com formulário, eu gosto da formik e react final form:</p>
<ul><li><a href="https://jaredpalmer.com/formik/docs/overview" rel="nofollow">https://jaredpalmer.com/formik/docs/overview</a></li><li><a href="https://github.com/final-form/react-final-form" rel="nofollow">https://github.com/final-form/react-final-form</a></li></ul>
<p>espero ter ajudado.</p>