Appending a line to a file if absent

echogrepmaketext processing

I'd like to add a series of commands to a Makefile that append config lines when they are not already present. I've done this in the past in a manner like so:

grep -vq "keyword" /a/b/c.conf && echo "abc keyword" >> /a/b/c.conf

But, I'm clearly overlooking something. The command as-is causes the config line to be duplicated when re-run.

A manual test shows the pattern works as expected:

grep -vq "keyword" /a/b/c.conf && echo "the line is absent"

… prints the line is absent only when the line is actually absent. And, the echo command is correctly not executed when the line is present.

What am I missing?

^{Note: The examples above are condensed for readability. In reality, there will be many similar commands. Here's the particular command I've tried:}

^{grep -vq "md_module" /etc/httpd/conf.modules.d/00-ssl.conf && echo "LoadModule md_module modules/mod_md.so" >> /etc/httpd/conf.modules.d/00-ssl.conf}

Best Answer

The problem is that grep -v will match lines that do not match the expression, not files that do not match it...

So if your file has any lines that do not match it, grep -v will match those lines and so grep will return successful.

A better approach is to use a positive match for the keyword and then use || (instead of &&) to append the line if needed:

grep -q "keyword" /a/b/c.conf || echo "abc keyword" >> /a/b/c.conf

You probably got your test with echo "the line is absent" to say it was absent when it was indeed absent... And maybe to do nothing if that was the only line. If you test this further, I think you'll see that as long as it does have any lines that do not match keyword, you'll get a match.

I hope this clarifies it!

Related Solutions

Bash – Multicolored Grep

Here's a different approach. I have a little Perl script which I have already posted in another answer that will highlight the user provided patterns in different colors. A slightly modified version of the script will act like grep:

#!/usr/bin/env perl
use Getopt::Std;
use strict;
use Term::ANSIColor; 

my %opts;
getopts('hic:l:',\%opts);
    if ($opts{h}){
      print<<EoF; 
Use -l to specify the pattern(s) to highlight. To specify more than one 
pattern use commas. 

-l : A Perl regular expression to be colored. Multiple expressions can be
     passed as comma separated values: -l foo,bar,baz
-i : makes the search case sensitive
-c : comma separated list of colors;

EoF
      exit(0);
    }

my $case_sensitive=$opts{i}||undef;
my @color=('bold red','bold blue', 'bold yellow', 'bold green', 
       'bold magenta', 'bold cyan', 'yellow on_blue', 
       'bright_white on_yellow', 'bright_yellow on_red', 'white on_black');
if ($opts{c}) {
   @color=split(/,/,$opts{c});
}
my @patterns;
if($opts{l}){
     @patterns=split(/,/,$opts{l});
}
else{
    $patterns[0]='\*';
}

# Setting $| to non-zero forces a flush right away and after 
# every write or print on the currently selected output channel. 
$|=1;

while (my $line=<>) 
{ 
    my $want=0;
    for (my $c=0; $c<=$#patterns; $c++){
    if($case_sensitive){
        if($line=~/$patterns[$c]/){
           $line=~s/($patterns[$c])/color("$color[$c]").$1.color("reset")/ge;
           $want++;
        }
    }
    else{
        if($line=~/$patterns[$c]/i){
          $line=~s/($patterns[$c])/color("$color[$c]").$1.color("reset")/ige;
          $want++;
        }
      }
    }
print STDOUT $line if $want>0;
}

If you save that script as cgrep somewhere in your PATH and make it executable, you can specify up to 10 different patterns, each of which will be printed in a different color:

enter image description here

$ cgrep -h
Use -l to specify the pattern(s) to highlight. To specify more than one 
pattern use commas. 

-l : A Perl regular expression to be colored. Multiple expressions can be
     passed as comma separated values: -l foo,bar,baz
-i : makes the search case sensitive
-c : comma separated list of colors;

Shell Script – Cut Tab-Delimited Text File Lines to 80 Characters

I think you're looking for expand and/or unexpand. It seems you're trying to ensure a \tab width counts as 8 chars rather than the single one. fold will do that as well, but it will wrap its input to the next line rather than truncating it. I think you want:

expand < input | cut -c -80

expand and unexpand are both POSIX specified:

The expand utility shall write files or the standard input to the standard output with \tab characters replaced with one or more space characters needed to pad to the next tab stop. Any backspace characters shall be copied to the output and cause the column position count for tab stop calculations to be decremented; the column position count shall not be decremented below zero.

Pretty simple. So, here's a look at what this does:

unset c i; set --;                                                             
until [ "$((i+=1))" -gt 10 ]; do set -- "$@" "$i" "$i"; done                      
for c in 'tr \\t \ ' expand;  do eval '                                           
    { printf "%*s\t" "$@"; echo; } | 
      tee /dev/fd/2 |'"$c"'| { 
      tee /dev/fd/3 | wc -c >&2; } 3>&1 |
      tee /dev/fd/2 | cut -c -80'
done

The until loop at top gets a set of data like...

1 1 2 2 3 3 ...

It printfs this with the %*s arg padding flag so for each of those in the set printf will pad with as many spaces as are in the number of the argument. To each one it appends a \tab character.

All of the tees are used to show the effects of each filter as it is applied.

And the effects are these:

1        2        3        4        5        6        7        8                9               10
1  2   3    4     5      6       7        8         9         10 
1  2   3    4     5      6       7        8         9         10 
66
1        2        3        4        5        6        7        8                9               10
1        2        3        4        5        6        7        8                9               10 
1        2        3        4        5        6        7        8                
105

Those rows are lined up in two sets like...

output of printf ...; echo
output of tr ... or expand
output of cut
output of wc

The top four rows are the results of the tr filter - in which each \tab is converted to a single space.

And the bottom four the results of the expand chain.

Best Answer

Related Solutions

Bash – Multicolored Grep

Shell Script – Cut Tab-Delimited Text File Lines to 80 Characters

Related Question