d45747123a55f60acf2ea913b3df6b03be906537
[fcscs/fcscs.git] / bin / fcscs
1 #!/usr/bin/perl
2
3 # fcscs - fast curses screen content select
4
5 # Copyright (C) 2013-2016  Simon Ruderich
6 #
7 # This program is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU General Public License as published by
9 # the Free Software Foundation, either version 3 of the License, or
10 # (at your option) any later version.
11 #
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 # GNU General Public License for more details.
16 #
17 # You should have received a copy of the GNU General Public License
18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
19
20
21 use strict;
22 use warnings;
23
24 use v5.10; # say, state
25
26 use Encode ();
27 use Fcntl ();
28 use I18N::Langinfo ();
29
30 use Curses ();
31
32 our $VERSION = '0.01';
33
34
35 =head1 NAME
36
37 fcscs - fast curses screen content select
38
39 =head1 SYNOPSIS
40
41 B<fcscs> [I<options>] I<path/to/screen/capture/file>
42
43 =head1 DESCRIPTION
44
45 B<fcscs> is a small tool which allows quick selection of terminal screen
46 contents (like URLs, paths, regex matches, etc.) and passes the selection to
47 GNU Screen's or Tmux's buffer or any other program. The selection can then
48 quickly be pasted, e.g. in the shell. Requires GNU Screen or Tmux. It's
49 licensed under the GPL 3 or later.
50
51 =head1 OPTIONS
52
53 None so far.
54
55 =head1 USAGE
56
57 Short overview of the general usage, details below:
58
59     - start fcscs
60     - configure actions (optional)
61         - enable pasting
62         - ...
63     - select mode (optional, URL mode is used on startup):
64         - f: file paths
65         - u: URLs
66         - ...
67         - /: search mode
68     - for `normal' modes:
69         - select match by displayed number or <return> for lowest numbered
70           match
71         - configured action is run, e.g. URL is opened with browser
72     - for `search' mode:
73         - perform incremental search
74         - on <return> go to `normal' mode to select a match
75         - after the match is selected wait for confirmation or extension
76         - confirmation: <return> run previously selected action
77         - extension: change match, e.g. select complete word or line
78
79 GNU Screen setup (add to F<~/.screenrc>):
80
81     bind ^B eval "hardcopy $HOME/.tmp/screen-fcscs" "screen fcscs $HOME/.tmp/screen-fcscs"
82
83 Tmux setup (add to F<~/.tmux.conf>):
84
85     bind-key C-b capture-pane \; save-buffer ~/.tmp/tmux-fcscs \; delete-buffer \; new-window "fcscs ~/.tmp/tmux-fcscs"
86
87 This requires a writable ~/.tmp directory. Adapt the mapping according to your
88 preferences. Ensure these files are not readable by others as they can contain
89 private data (umask or protected directory). B<fcscs> must be in your C<$PATH>
90 for the above mappings to work.
91
92 Pressing the configured mapping (Prefix Ctrl-B in this example) opens B<fcscs>
93 in a new GNU screen/Tmux window. After selection, the content is either passed
94 to external programs (e.g. for URLs) or copied to the paste buffer or directly
95 pasted in your previous window and the new window is closed.
96
97 To select a match just type its number. If the match is unique, the entry is
98 automatically selected (e.g. you press 2 and there are only 19 matches). If
99 there are multiple matches left (e.g. you press 1 and there are more than ten
100 matches available), press return to select the current match (1 in this case)
101 or another number to select the longer match. Use backspace to remove the last
102 entered number.
103
104 Press return before entering a number to select the last (lowest numbered)
105 match. To abort without selecting any match either use "q".
106
107 To change the selection mode (e.g. paths, files, etc.) use one of the mappings
108 explained below. Per default URLs are selected, see options for a way to
109 change this.
110
111 I<NOTE>: Opening URLs in the browser passes the URL via the command line which
112 leaks URLs to other users on the current system via C<ps aux> or C<top>.
113
114 I<NOTE>: When yanking (copying) a temporary file is used to pass the data to
115 GNU screen/Tmux without exposing it to C<ps aux> or C<top>. However this may
116 leak data if those temporary files are written to disk. To prevent this change
117 your C<$TMP> to point to a memory-only location or encrypted storage.
118
119 If no window appears, try running B<fcscs> manually to catch the error message
120 and please report the bug:
121
122     fcscs /path/to/screen-or-tmux-fcscs-file
123
124
125 =head1 MODES
126
127 =cut
128
129
130 # CLASSES
131
132 # Helper class for drawing on the screen using Curses.
133 package Screen {
134     sub init {
135         my ($class, $encoding) = @_;
136
137         # Prefer strict UTF-8 handling (see perldoc Encode); just in case.
138         if (lc $encoding eq 'utf8') {
139             $encoding = 'UTF-8';
140         }
141         # Get Encode object to speed up decode()/encode().
142         my $encoding_object = Encode::find_encoding($encoding);
143         die "unsupported encoding '$encoding'" unless ref $encoding_object;
144
145         my $curses = Curses->new or die $!;
146
147         my $self = {
148             encoding        => $encoding,
149             encoding_object => $encoding_object,
150             curses          => $curses,
151             debug           => 0,
152             prompt          => {
153                 flags => undef,
154                 name  => undef,
155                 value => undef,
156             },
157         };
158         bless $self, $class;
159
160         Curses::start_color;
161         # Allow default colors by passing -1 to init_pair. A default color is
162         # not drawn on screen thus allowing terminals with pseudo-transparency
163         # to use the transparent background in place of the default color.
164         Curses::use_default_colors;
165
166         Curses::cbreak;
167         Curses::noecho;
168         $self->cursor(0);
169
170         return $self;
171     }
172     sub deinit {
173         my ($self) = @_;
174
175         Curses::nocbreak;
176         Curses::echo;
177         $self->cursor(1);
178
179         Curses::endwin;
180         return;
181     }
182
183     # Convert between Perl's internal encoding and the terminal's encoding.
184     sub encode {
185         my ($self, $string) = @_;
186         return $self->{encoding_object}->encode($string);
187     }
188     sub decode {
189         my ($self, $string) = @_;
190         return eval { # returns undef on decode failure
191             $self->{encoding_object}->decode($string, Encode::FB_CROAK);
192         };
193     }
194
195     # Create attribute for the given fore-/background colors.
196     sub color_pair {
197         my ($self, $fg, $bg) = @_;
198
199         state $next_color_pair = 1; # must start at 1 for init_pair()
200
201         Curses::init_pair($next_color_pair, $fg, $bg);
202         return Curses::COLOR_PAIR($next_color_pair++);
203     }
204
205     # Draw a string which must fit in the current line. Wrapping/clipping is
206     # not supported and must be handled by the caller.
207     sub draw_simple {
208         my ($self, $y, $x, $attributes, $string) = @_;
209
210         die if $string =~ /\n/;
211         # FIXME: wide characters
212         die if $x + length $string > $self->width;
213
214         $self->{curses}->attron($attributes) if defined $attributes;
215         $self->{curses}->addstr($y, $x, $self->encode($string));
216         $self->{curses}->attroff($attributes) if defined $attributes;
217         return;
218     }
219     # Like draw_simple(), but the string is automatically clipped.
220     sub draw_clipped {
221         my ($self, $y, $x, $attributes, $string) = @_;
222
223         # FIXME: wide characters
224         $string = substr $string, 0, $self->width - $x;
225         $self->draw_simple($y, $x, $attributes, $string);
226         return;
227     }
228     sub draw {
229         my ($self, $y, $x, $attributes, $string) = @_;
230
231         die unless defined $string;
232
233         while (1) {
234             my $offset;
235             # We must print each line separately. Search for next newline or
236             # line end, whichever is closer.
237             if ($string =~ /\n/) {
238                 $offset = $-[0];
239             }
240             # FIXME: wide characters
241             if ($x + length $string > $self->width) {
242                 my $new_offset = $self->width - $x;
243                 if (not defined $offset or $offset > $new_offset) {
244                     $offset = $new_offset;
245                 }
246             }
247             last unless defined $offset;
248
249             # FIXME: wide characters
250             $self->draw_simple($y, $x, $attributes, substr $string, 0, $offset);
251
252             # Don't draw "\n" itself.
253             if ("\n" eq substr $string, $offset, 1) {
254                 $offset++;
255             }
256
257             $string = substr $string, $offset;
258
259             $y++;
260             $x = 0;
261         }
262
263         $self->draw_simple($y, $x, $attributes, $string);
264         return $y;
265     }
266
267     sub draw_prompt {
268         my ($self, $config) = @_;
269
270         $self->debug('draw_prompt', 'started');
271
272         my $x = 0;
273         my $y = $self->height - 1;
274
275         # Clear line for better visibility.
276         $self->draw_simple($y, $x, undef, ' ' x $self->width);
277
278         # Draw prompt flags.
279         if (defined (my $s = $self->{prompt}{flags})) {
280             $s = "[$s]";
281             $self->debug('draw_prompt', $s);
282             $self->draw_clipped($y, $x, $config->{attribute}{prompt_flags}, $s);
283             $x += length($s) + 1; # space between next element
284         }
285         # Draw prompt name.
286         if (defined (my $s = $self->{prompt}{name})) {
287             $s = "[$s]";
288             $self->debug('draw_prompt', $s);
289             $self->draw_clipped($y, $x, $config->{attribute}{prompt_name}, $s);
290             $x += length($s) + 1;
291         }
292         # Draw prompt value, e.g. a search field.
293         if (defined (my $s = $self->{prompt}{value})) {
294             $self->debug('draw_prompt', $s);
295             $self->draw_clipped($y, $x, undef, $s);
296             $x += length($s) + 1;
297         }
298         return;
299     }
300
301     sub draw_matches {
302         my ($self, $config, $matches_remove, $matches_add) = @_;
303
304         foreach (@{$matches_remove}) {
305             $self->draw($_->{y}, $_->{x}, Curses::A_NORMAL, $_->{string});
306         }
307
308         my $attr_id     = $config->{attribute}{match_id};
309         my $attr_string = $config->{attribute}{match_string};
310
311         foreach (@{$matches_add}) {
312             $self->draw($_->{y}, $_->{x}, $attr_string, $_->{string});
313             if (defined $_->{id}) {
314                 $self->draw($_->{y}, $_->{x}, $attr_id, $_->{id});
315             }
316         }
317         return;
318     }
319
320     sub die {
321         my ($self, @args) = @_;
322
323         my $attr = $self->color_pair(Curses::COLOR_RED, -1) | Curses::A_BOLD;
324
325         # Clear the screen to improve visibility of the error message.
326         $self->{curses}->clear;
327
328         my $y = $self->draw(0, 0, $attr, "@args");
329
330         if ($self->{debug}) {
331             my $msg;
332             eval {
333                 require Devel::StackTrace;
334             };
335             if ($@) {
336                 $msg = "Devel::StackTrace missing, no stack trace.\n";
337             } else {
338                 my $trace = Devel::StackTrace->new;
339                 $msg = "Stack trace:\n" . $trace->as_string;
340             }
341             $y = $self->draw($y + 1, 0, Curses::A_NORMAL, $msg);
342         }
343
344         $self->draw($y + 1, 0, Curses::A_NORMAL,
345                     'Press any key to terminate fcscs.');
346         $self->refresh;
347
348         $self->getch;
349         $self->deinit;
350         exit 1;
351     }
352     sub debug {
353         my ($self, $module, @args) = @_;
354
355         return if not $self->{debug};
356
357         state $fh; # only open the file once per run
358         if (not defined $fh) {
359             # Ignore errors if the directory doesn't exist.
360             if (not open $fh, '>', "$ENV{HOME}/.config/fcscs/log") {
361                 $fh = undef; # a failed open still writes a value to $fh
362                 return;
363             }
364         }
365
366         foreach (@args) {
367             $_ = $self->encode($_);
368         }
369         say $fh "$module: @args";
370         return;
371     }
372
373
374     sub prompt {
375         my ($self, %settings) = @_;
376
377         foreach (keys %settings) {
378             CORE::die if not exists $self->{prompt}{$_};
379             $self->{prompt}{$_} = $settings{$_};
380         }
381         return;
382     }
383
384     # Wrapper for Curses.
385     sub width   { return $Curses::COLS; }
386     sub height  { return $Curses::LINES; }
387     sub refresh { return $_[0]->{curses}->refresh; }
388     sub getch   { return $_[0]->{curses}->getch; }
389     sub cursor  { Curses::curs_set($_[1]); return; }
390 }
391
392
393
394 # FUNCTIONS
395
396 sub prepare_input {
397     my ($screen, $input_ref) = @_;
398
399     # Make sure the input fits on the screen by removing the top lines if
400     # necessary.
401     splice @{$input_ref}, 0, -$screen->height;
402
403     # Pad each line with spaces to the screen width to correctly handle
404     # multi-line regexes.
405     # FIXME: wide characters
406     my @padded = map { sprintf '%-*s', $screen->width, $_ } @{$input_ref};
407
408     my $string = join "\n", @padded;
409     return {
410         string => $string,
411         lines  => $input_ref,
412         width  => $screen->width + 1,
413                   # + 1 = "\n", used in input_match_offset_to_coordinates
414     };
415 }
416
417 sub input_match_offset_to_coordinates {
418     my ($width, $offset) = @_;
419
420     die unless defined $offset;
421
422     my $y = int($offset / $width);
423     my $x = $offset - $y * $width;
424     return ($x, $y);
425 }
426
427 sub get_regex_matches {
428     my ($input, $regex) = @_;
429
430     my @matches;
431     while ($input->{string} =~ /$regex/g) {
432         my $offset = $-[1];
433         die "Match group required in regex '$regex'" if not defined $offset;
434
435         my ($x, $y) = input_match_offset_to_coordinates($input->{width},
436                                                         $offset);
437         push @matches, { x => $x, y => $y, offset => $offset, string => $1 };
438     }
439     return @matches;
440 }
441
442
443 sub run_command {
444     my ($screen, $config, $cmd) = @_;
445
446     $screen->debug('run_command', "running @{$cmd}");
447
448     my $exit = do {
449         # Perl's system() combined with a $SIG{__WARN__} which die()s has
450         # issues due to the fork. The die() in the __WARN__ handler doesn't
451         # die but the program continues after the system().
452         #
453         # If the forked process fails to exec (e.g. program not found) then
454         # the __WARN__ handler is called (because a warning is about to be
455         # displayed) and the die() should display a message and terminate the
456         # process. But due to the fork it doesn't terminate the parent process
457         # and instead changes the return value of system(); it's no longer -1
458         # which makes it impossible to detect that case.
459         #
460         # Perl < 5.18 (found in 5.14) doesn't setup $$ during system() which
461         # makes it impossible to detect if the handler was called from inside
462         # the child.
463         #
464         # Instead, just ignore any warnings during the system(). Thanks to
465         # mauke in #perl on Freenode (2013-10-29 23:30 CET) for the idea to
466         # use no warnings and anno for testing a more recent Perl version with
467         # a working $$.
468         no warnings;
469
470         my @cmd = map { $screen->encode($_) } @{$cmd};
471         system { $cmd[0] } @cmd;
472     };
473     if ($exit != 0) {
474         my $msg;
475         if ($? == -1) {
476             $msg = 'failed to execute: ' . $!;
477         } elsif ($? & 127) {
478             $msg = 'killed by signal ' . ($? & 127);
479         } else {
480             $msg = 'exited with code ' . ($? >> 8);
481         }
482         die "system(@{$cmd}) $msg.";
483     }
484     return;
485 }
486 sub run_in_background {
487     my ($screen, $sub) = @_;
488
489     $screen->debug('run_in_background', "running $sub");
490
491     my $pid = fork;
492     defined $pid or die $!;
493
494     if ($pid == 0) {
495         # The terminal multiplexer sends a SIGHUP to the process when it
496         # closes the window (because the parent process has exited).
497         local $SIG{HUP} = 'IGNORE';
498
499         # Necessary for GNU screen or it'll keep the window open until the
500         # paste command has run.
501         close STDIN  or die $!;
502         close STDOUT or die $!;
503         close STDERR or die $!;
504
505         # Double-fork to prevent zombies.
506         my $pid = fork;
507         defined $pid or die $!;
508         if ($pid == 0) { # child
509             $sub->();
510         }
511         exit;
512     }
513     waitpid $pid, 0 or die $!;
514     return;
515 }
516
517
518 sub select_match {
519     my ($name, $screen, $config, $input, $matches) = @_;
520
521     $screen->debug('select_match', 'started');
522
523     return if @{$matches} == 0;
524     # Don't return on initial run to give the user a chance to select another
525     # mode, e.g. to switch from URL selection to search selection.
526     if (@{$matches} == 1 and not $config->{state}{initial}) {
527         return { match => $matches->[0] };
528     }
529     $config->{state}{initial} = 0;
530
531     my @sorted = sort { $b->{y} <=> $a->{y} or $b->{x} <=> $a->{x} } @{$matches};
532
533     my $i = 1;
534     foreach (@sorted) {
535         $_->{id} = $i++;
536     }
537
538     $screen->prompt(name => $name, value => undef);
539     $screen->draw_prompt($config);
540
541     $screen->draw_matches($config, [], $matches);
542     $screen->refresh;
543
544     my $number = 0;
545     while (1) {
546         my $char = $screen->getch;
547         if ($char =~ /^\d$/) {
548             $number = $number * 10 + $char;
549         } elsif ($char eq "\b" or $char eq "\x7f") { # backspace
550             $number = int($number / 10);
551         } elsif ($char eq "\n") {
552             if ($number == 0) { # number without selection matches last entry
553                 $number = 1;
554             }
555             last;
556
557         # Selecting a new mode requires falling through into the main input
558         # loop and then starting the new mode.
559         } elsif (defined $config->{mapping}{mode}{$char}) {
560             $screen->draw_matches($config, $matches, []); # clear matches
561             return { key => $char };
562         # All other mappings stay in the current mode.
563         } elsif (defined (my $m = $config->{mapping}{simple}{$char})) {
564             $m->($char, $screen, $config, $input);
565             next;
566
567         } else {
568             next; # ignore unknown mappings
569         }
570
571         last if $number > 0 and $number * 10 > @{$matches}; # unique match
572
573         my @remaining = $number == 0
574                       ? @{$matches}
575                       : grep { $_->{id} =~ /^$number/ } @{$matches};
576         $screen->draw_matches($config, $matches, \@remaining);
577         $screen->refresh;
578     }
579
580     $screen->draw_matches($config, $matches, []); # remove matches
581
582     foreach (@{$matches}) {
583         return { match => $_ } if $_->{id} == $number;
584     }
585     $screen->debug('select_match', 'no match selected');
586     return { match => undef };
587 }
588
589 sub extend_match_regex_left {
590     my ($line, $match, $regex) = @_;
591
592     my $s = reverse substr $line, 0, $match->{x};
593     if ($s =~ /^($regex)/) {
594         $match->{string}  = reverse($1) . $match->{string};
595         $match->{x}      -= length $1;
596         $match->{offset} -= length $1;
597     }
598     return;
599 }
600 sub extend_match_regex_right {
601     my ($line, $match, $regex) = @_;
602
603     my $s = substr $line, $match->{x} + length $match->{string};
604     if ($s =~ /^($regex)/) {
605         $match->{string} .= $1;
606     }
607     return;
608 }
609 sub extend_match {
610     my ($screen, $config, $input, $match) = @_;
611
612     $screen->debug('extend_match', 'started');
613
614     $screen->prompt(name => 'extend', value => undef);
615     $screen->draw_prompt($config);
616
617     delete $match->{id}; # don't draw any match ids
618     $screen->draw_matches($config, [], [$match]);
619     $screen->refresh;
620
621     my $line = $input->{lines}[$match->{y}];
622
623     while (1) {
624         my $match_old = \%{$match};
625
626         my $char = $screen->getch;
627         if ($char eq "\n") { # accept match
628             last;
629
630         } elsif ($char eq 'w') { # select current word (both directions)
631             extend_match_regex_left($line,  $match, qr/\w+/);
632             extend_match_regex_right($line, $match, qr/\w+/);
633         } elsif ($char eq 'b') { # select current word (only left)
634             extend_match_regex_left($line,  $match, qr/\w+/);
635         } elsif ($char eq 'e') { # select current word (only right)
636             extend_match_regex_right($line, $match, qr/\w+/);
637
638         } elsif ($char eq 'W') { # select current WORD (both directions)
639             extend_match_regex_left($line,  $match, qr/\S+/);
640             extend_match_regex_right($line, $match, qr/\S+/);
641         } elsif ($char eq 'B') { # select current WORD (only left)
642             extend_match_regex_left($line,  $match, qr/\S+/);
643         } elsif ($char eq 'E') { # select current WORD (only right)
644             extend_match_regex_right($line, $match, qr/\S+/);
645
646         } elsif ($char eq '^') { # select to beginning of line
647             extend_match_regex_left($line, $match, qr/.+/);
648         } elsif ($char eq '$') { # select to end of line
649             extend_match_regex_right($line, $match, qr/.+/);
650
651         # Allow mode changes if not overwritten by local mappings.
652         } elsif (defined $config->{mapping}{mode}{$char}) {
653             $screen->draw_matches($config, [$match_old], []); # clear match
654             return { key => $char };
655
656         } else {
657             next; # ignore unknown mappings
658         }
659
660         $screen->draw_matches($config, [$match_old], [$match]);
661         $screen->refresh;
662     }
663
664     $screen->debug('extend_match', 'done');
665
666     return { match => $match };
667 }
668
669
670 sub mapping_paste {
671     my ($key, $screen, $config, $input) = @_;
672
673     $screen->debug('mapping_paste', 'started');
674
675     $config->{state}{handler} = $config->{handler}{paste};
676
677     $screen->prompt(flags => 'P'); # paste
678     $screen->draw_prompt($config);
679     $screen->refresh;
680
681     return {};
682 }
683 sub mapping_yank {
684     my ($key, $screen, $config, $input) = @_;
685
686     $screen->debug('mapping_yank', 'started');
687
688     $config->{state}{handler} = $config->{handler}{yank};
689
690     $screen->prompt(flags => 'Y'); # yank
691     $screen->draw_prompt($config);
692     $screen->refresh;
693
694     return {};
695 }
696
697
698 =head2 NORMAL MODES
699
700 Normal modes select matches by calling a function which returns them, e.g. by
701 using a regex.
702
703 The following normal modes are available:
704
705 =over 4
706
707 =item B<path mode> select relative/absolute paths
708
709 =item B<url mode>  select URLs
710
711 =back
712
713 =cut
714 sub mapping_mode_path {
715     my ($key, $screen, $config, $input) = @_;
716
717     $screen->debug('mapping_mode_path', 'started');
718
719     my @matches = get_regex_matches($input, $config->{regex}{path});
720     return {
721         select  => 'path select',
722         matches => \@matches,
723         handler => $config->{handler}{yank},
724     };
725 }
726 sub mapping_mode_url {
727     my ($key, $screen, $config, $input) = @_;
728
729     $screen->debug('mapping_mode_url', 'started');
730
731     my @matches = get_regex_matches($input, $config->{regex}{url});
732     return {
733         select  => 'url select',
734         matches => \@matches,
735         handler => $config->{handler}{url},
736     };
737 }
738
739 =head2 SEARCH MODE (AND EXTEND MODE)
740
741 Search mode is a special mode which lets you type a search string (a Perl
742 regex) and then select one of the matches. Afterwards you can extend the
743 match. For example select the complete word or to the end of the line. This
744 allows quick selection of arbitrary text.
745
746 The following mappings are available during the extension mode (not
747 configurable at the moment):
748
749 =over 4
750
751 =item B<w> select current word
752
753 =item B<b> extend word to the left
754
755 =item B<e> extend word to the right
756
757 =item B<W> select current WORD
758
759 =item B<B> extend WORD to the left
760
761 =item B<E> extend WORD to the right
762
763 =item B<^> extend to beginning of line
764
765 =item B<$> extend to end of line
766
767 =back
768
769 C<word> includes any characters matching C<\w+>, C<WORD> any non-whitespace
770 characters (C<\S+>), just like in Vim.
771
772 =cut
773 sub mapping_mode_search {
774     my ($key, $screen, $config, $input) = @_;
775
776     $screen->debug('mapping_mode_search', 'started');
777
778     $screen->cursor(1);
779
780     my $search = ''; # encoded
781     my @last_matches;
782     while (1) {
783         # getch doesn't return decoded characters but raw input bytes. Wait
784         # until the input character is complete.
785         my $value = $screen->decode($search);
786         $value = '' unless defined $value; # undef on decode failure
787
788         $screen->prompt(name => 'search', value => $value);
789         $screen->draw_prompt($config);
790         $screen->refresh;
791
792         my $char = $screen->getch;
793         # TODO: readline editing support
794         if ($char eq "\n") {
795             last;
796         } elsif ($char eq "\b" or $char eq "\x7f") { # backspace
797             # Remove a character, not a byte.
798             $search = $screen->decode($search);
799             chop $search;
800             $search = $screen->encode($search);
801         } else {
802             $search .= $char;
803             next unless defined $screen->decode($search);
804         }
805
806         my @matches;
807         if ($search ne '') {
808             my $case = '';
809             if (($config->{setting}{smartcase} and $search eq lc $search)
810                     or $config->{setting}{ignorecase}) {
811                 $case = '(?i)';
812             }
813             # Ignore invalid regexps.
814             # TODO: display warning on error?
815             eval {
816                 @matches = get_regex_matches($input, qr/($case$search)/);
817             };
818         }
819         $screen->draw_matches($config, \@last_matches, \@matches);
820         @last_matches = @matches;
821     }
822
823     $screen->cursor(0);
824
825     return {
826         select  => 'search',
827         matches => \@last_matches,
828         extend  => 1,
829         handler => $config->{handler}{yank},
830     };
831 }
832
833 sub mapping_quit {
834     my ($key, $screen, $config, $input) = @_;
835
836     # Key is necessary to fall through to main event loop which then quits.
837     return { key => $key, quit => 1 };
838 }
839
840
841 sub handler_yank {
842     my ($screen, $config, $match) = @_;
843
844     $screen->debug('handler_yank', 'started');
845
846     require File::Temp;
847
848     # Use a temporary file to prevent leaking the yanked data to other users
849     # with the command line, e.g. ps aux or top.
850     my ($fh, $tmp) = File::Temp::tempfile(); # dies on its own
851     print $fh $screen->encode($match->{value});
852     close $fh or die $!;
853
854     if ($config->{setting}{multiplexer} eq 'screen') {
855         $screen->debug('handler_yank', 'using screen');
856
857         # GNU screen displays an annoying "Slurping X characters into buffer".
858         # Use 'msgwait 0' as a hack to disable it.
859         my $msgwait = $config->{setting}{screen_msgwait};
860         run_command($screen, $config, ['screen', '-X', 'msgwait', 0]);
861         run_command($screen, $config, ['screen', '-X', 'readbuf', $tmp]);
862         run_command($screen, $config, ['screen', '-X', 'msgwait', $msgwait]);
863     } elsif ($config->{setting}{multiplexer} eq 'tmux') {
864         $screen->debug('handler_yank', 'using tmux');
865
866         run_command($screen, $config, ['tmux', 'load-buffer', $tmp]);
867     } else {
868         die 'unsupported multiplexer';
869     }
870
871     unlink $tmp or die $!;
872     return;
873 }
874 sub handler_paste {
875     my ($screen, $config, $match) = @_;
876
877     $screen->debug('handler_paste', 'started');
878
879     require Time::HiRes;
880
881     my @cmd;
882     if ($config->{setting}{multiplexer} eq 'screen') {
883         $screen->debug('handler_paste', 'using screen');
884         @cmd = qw( screen -X paste . );
885     } elsif ($config->{setting}{multiplexer} eq 'tmux') {
886         $screen->debug('handler_paste', 'using tmux');
887         @cmd = qw( tmux paste-buffer );
888     } else {
889         die 'unsupported multiplexer';
890     }
891
892     run_in_background($screen, sub {
893         # We need to get the data in the paste buffer before we can paste
894         # it.
895         handler_yank($screen, $config, $match);
896
897         # Sleep until we switch back to the current window.
898         Time::HiRes::usleep($config->{setting}{paste_sleep});
899
900         run_command($screen, $config, \@cmd);
901     });
902     return;
903 }
904 sub handler_url {
905     my ($screen, $config, $match) = @_;
906
907     $screen->debug('handler_url', "opening $match->{value}");
908
909     run_in_background($screen, sub {
910         my @cmd = ( @{$config->{setting}{browser}}, $match->{value} );
911         run_command($screen, $config, \@cmd);
912     });
913     return;
914 }
915
916
917
918 # CONFIGURATION DEFAULTS
919
920 =head1 CONFIGURATION
921
922 fcscs is configured through F<~/.fcscsrc> or F<~/.config/fcscs/fcscsrc> which
923 is a normal Perl script with all of Perl's usual features.
924
925 All configuration values are stored in the hash C<%config>. All manually
926 defined keys overwrite the default settings.
927
928 A simple F<~/.fcscsrc> could look like this (for details about the used
929 settings see below):
930
931     use strict;
932     use warnings;
933
934     use Curses; # for COLOR_* and A_* constants
935
936     our %config;
937
938     # Draw matches in blue.
939     $config{attribute}{match_string} = color_pair(COLOR_BLUE, -1);
940     # Enable Vim-like 'smartcase', ignore case until an upper character is
941     # searched.
942     $config{setting}{smartcase} = 1;
943
944     # Use chromium to open URLs if running under X, elinks otherwise.
945     if (defined $ENV{DISPLAY}) {
946         $config{setting}{browser} = ['chromium'];
947     } else {
948         $config{setting}{browser} = ['elinks'];
949     }
950
951     # Let fcscs know the file was loaded successfully.
952     1;
953
954 =cut
955
956
957 if (@ARGV != 1) {
958     require Pod::Usage;
959     Pod::Usage::pod2usage(2);
960 }
961
962
963 # Determine terminal encoding from the environment ($ENV{LANG} or similar).
964 my $encoding = I18N::Langinfo::langinfo(I18N::Langinfo::CODESET);
965
966 my $screen = Screen->init($encoding);
967
968 # We must restore the screen before exiting.
969 local $SIG{INT} = sub {
970     $screen->deinit;
971     exit 128 + 2;
972 };
973 # Make all warnings fatal to make sure they don't get lost (stderr is normally
974 # not displayed).
975 local $SIG{__WARN__} = sub {
976     $screen->die('warning', @_);
977 };
978
979
980
981 =head2 MAPPINGS
982
983 I<NOTE>: Mappings are split in two categories: Mode mappings which change the
984 selection and may receive additional input (e.g. a search string) and simple
985 mappings which only change some value. Mode mappings are configured via
986 C<$config{mapping}{mode}>, simple mappings via C<$config{mapping}{simple}>.
987
988 The following mode mappings are available by default (the function to remap
989 them in parentheses):
990
991 =over
992
993 =item B<f> select absolute/relative paths (C<\&mapping_mode_path>)
994
995 =item B<u> select URLs (C<\&mapping_mode_url>)
996
997 =item B</> search for regex to get selection (C<\&mapping_mode_search>)
998
999 =item B<q> quit fcscs (C<\&mapping_quit>)
1000
1001 =back
1002
1003 The following simple mappings are available by default:
1004
1005 =over
1006
1007 =item B<p> enable pasting (C<\&mapping_paste>)
1008
1009 =item B<y> enable yanking (copying) (C<\&mapping_yank>)
1010
1011 =back
1012
1013 All (single-byte) keys except numbers, backspace and return can be mapped.
1014
1015 Unknown mappings are ignored when pressing keys.
1016
1017 To remove a default mapping, delete it from the mapping hash.
1018
1019 Example:
1020
1021     # Map 'p' to select paths, 'P' to enable pasting.
1022     $config{mapping}{mode}{p} = \&mapping_mode_path;
1023     $config{mapping}{simple}{P} = \&mapping_paste;
1024
1025     # Disable 'f' mapping.
1026     delete $config{mapping}{mode}{f};
1027
1028 =cut
1029 my %mapping_mode = (
1030     f   => \&mapping_mode_path,
1031     u   => \&mapping_mode_url,
1032     '/' => \&mapping_mode_search,
1033     q   => \&mapping_quit,
1034 );
1035 my %mapping_simple = (
1036     p => \&mapping_paste,
1037     y => \&mapping_yank,
1038 );
1039
1040 =head2 ATTRIBUTES
1041
1042 Attributes are used to style the output. They must be Curses attributes.
1043 Defaults in parentheses (foreground, background, attribute).
1044
1045 =over
1046
1047 =item B<match_id>      attribute for match numbers (red, default, bold)
1048
1049 =item B<match_string>  attribute for matches (yellow, default, normal)
1050
1051 =item B<prompt_name>   attribute for prompt name (standout)
1052
1053 =item B<prompt_flags>  attribute for prompt flags (standout)
1054
1055 =back
1056
1057 Example:
1058
1059     # Draw prompt flags in bold red with default background color.
1060     $config{attribute}{prompt_flags}
1061         = Curses::A_BOLD
1062         | color_pair(Curses::COLOR_RED, -1);
1063
1064 =cut
1065 my %attribute = (
1066     match_id     => $screen->color_pair(Curses::COLOR_RED, -1)
1067                     | Curses::A_BOLD,
1068     match_string => $screen->color_pair(Curses::COLOR_YELLOW, -1),
1069     prompt_name  => Curses::A_STANDOUT,
1070     prompt_flags => Curses::A_STANDOUT,
1071 );
1072
1073 =head2 SETTINGS
1074
1075 Defaults in parentheses.
1076
1077 =over
1078
1079 =item B<debug>          enable debug mode, writes to I<~/.config/fcscs/log> (C<0>)
1080
1081 =item B<initial_mode>   start in this mode, must be a valid mode mapping (C<\&mapping_mode_url>)
1082
1083 =item B<multiplexer>    set multiplexer ("screen" or "tmux") if not autodetected (C<undef>)
1084
1085 =item B<ignorecase>     ignore case when searching (C<0>)
1086
1087 =item B<smartcase>      ignore case unless one uppercase character is searched (C<1>)
1088
1089 =item B<paste_sleep>    sleep x us before running paste command (C<100_000>)
1090
1091 =item B<screen_msgwait> GNU Screen's msgwait variable, used when yanking (C<5>)
1092
1093 =item B<browser>        browser command as array reference (C<['x-www-browser']>)
1094
1095 =back
1096
1097 Example:
1098
1099     # Select paths on startup instead of URLs.
1100     $config{setting}{initial_mode} = \&mapping_mode_path;
1101
1102 =cut
1103 my %setting = (
1104     # options
1105     debug          => 0,
1106     initial_mode   => \&mapping_mode_url,
1107     multiplexer    => undef,
1108     ignorecase     => 0,
1109     smartcase      => 1,
1110     paste_sleep    => 100_000,
1111     screen_msgwait => 5,
1112     # commands
1113     browser        => ['x-www-browser'],
1114 );
1115
1116 =head2 REGEXPS
1117
1118 =over
1119
1120 =item B<url>  used by C<\&mapping_mode_url()>
1121
1122 =item B<path> used by C<\&mapping_mode_path()>
1123
1124 =back
1125
1126 Example:
1127
1128     # Select all non-whitespace characters when searching for paths.
1129     $config{regex}{path} = qr{(\S+)};
1130
1131 =cut
1132 my %regex = (
1133     # Taken from urlview's default configuration file, thanks.
1134     url  => qr{((?:(?:(?:http|https|ftp|gopher)|mailto):(?://)?[^ <>"\t]*|(?:www|ftp)[0-9]?\.[-a-z0-9.]+)[^ .,;\t\n\r<">\):]?[^, <>"\t]*[^ .,;\t\n\r<">\):])},
1135     path => qr{(~?[a-zA-Z0-9_./-]*/[a-zA-Z0-9_./-]+)},
1136 );
1137
1138 =head2 HANDLERS
1139
1140 Handlers are used to perform actions on the selected string.
1141
1142 The following handlers are available, defaults in parentheses.
1143
1144 =over
1145
1146 =item B<yank>  used to yank (copy) selection to paste buffer (C<\&handler_yank>)
1147
1148 =item B<paste> used to paste selection into window (C<\&handler_paste>)
1149
1150 =item B<url>   used to open URLs (e.g. in a browser) (C<\&handler_url>)
1151
1152 =back
1153
1154 Example:
1155
1156     # Download YouTube videos with a custom wrapper, handle all other URLs
1157     # with the default URL handler.
1158     $config{handler}{url} = sub {
1159         my ($screen, $config, $match) = @_;
1160
1161         if ($match->{value} =~ m{^https://www.youtube.com/}) {
1162             return run_in_background($screen, sub {
1163                 run_command($screen, $config,
1164                             ['youtube-dl-wrapper', $match->{value}]);
1165             });
1166         }
1167         handler_url(@_);
1168     };
1169
1170 =cut
1171 my %handler = (
1172     yank  => \&handler_yank,
1173     paste => \&handler_paste,
1174     url   => \&handler_url,
1175 );
1176
1177 my %state = (
1178     initial => 1, # used by select_match() for 'initial_mode'
1179     handler => undef,
1180 );
1181
1182
1183
1184 # CONFIGURATION "API"
1185
1186 =head2 FUNCTIONS
1187
1188 The following functions are available:
1189
1190     color_pair($fg, $bg)
1191
1192 Create a new Curses attribute with the given fore- and background color.
1193
1194     mapping_mode_path()
1195     mapping_mode_url()
1196     mapping_mode_search()
1197
1198     mapping_paste()
1199     mapping_yank()
1200     mapping_quit()
1201
1202 Used as mappings, see L</MAPPINGS> above.
1203
1204     handler_yank()
1205     handler_paste()
1206     handler_url()
1207
1208 Used as handler to yank, paste selection or open URL in browser.
1209
1210     debug()
1211     get_regex_matches()
1212     select_match()
1213     run_command()
1214     run_in_background()
1215
1216 Helper functions when writing custom mappings, see the source for details.
1217
1218 Example:
1219
1220     TODO
1221
1222 =cut
1223
1224 # All variables and functions which are usable by ~/.fcscsrc.
1225 package Fcscs {
1226     our $screen; # "private"
1227     our %config;
1228
1229     sub color_pair { return $screen->color_pair(@_); }
1230
1231     sub mapping_mode_path { return main::mapping_mode_path(@_); }
1232     sub mapping_mode_url { return main::mapping_mode_url(@_); }
1233     sub mapping_mode_search { return main::mapping_mode_search(@_); }
1234
1235     sub mapping_paste { return main::mapping_paste(@_); }
1236     sub mapping_yank { return main::mapping_yank(@_); }
1237     sub mapping_quit { return main::mapping_quit(@_); }
1238
1239     sub handler_yank { return main::handler_yank(@_); }
1240     sub handler_paste { return main::handler_paste(@_); }
1241     sub handler_url { return main::handler_url(@_); }
1242
1243     sub debug { return main::debug(@_); }
1244
1245     sub get_regex_matches { return main::get_regex_matches(@_); }
1246     sub select_match { return main::select_match(@_); }
1247
1248     sub run_command { return main::run_command(@_); }
1249     sub run_in_background { return main::run_in_background(@_); }
1250 }
1251 $Fcscs::screen = $screen;
1252
1253
1254
1255 # LOAD USER CONFIG
1256
1257 # Alias %config and %Fcscs::config. %config is less to type.
1258 our %config;
1259 local *config = \%Fcscs::config;
1260
1261 $config{mapping}{mode}   = \%mapping_mode;
1262 $config{mapping}{simple} = \%mapping_simple;
1263 $config{attribute}       = \%attribute;
1264 $config{setting}         = \%setting;
1265 $config{regex}           = \%regex;
1266 $config{handler}         = \%handler;
1267 $config{state}           = \%state;
1268
1269 package Fcscs {
1270     my @configs = ("$ENV{HOME}/.fcscsrc",
1271                    "$ENV{HOME}/.config/fcscs/fcscsrc");
1272     foreach my $path (@configs) {
1273         my $decoded = $screen->decode($path);
1274
1275         # Load configuration file. Checks have a race condition if the home
1276         # directory is writable by an attacker (but then the user is screwed
1277         # anyway).
1278         next unless -e $path;
1279         if (not -O $path) {
1280             $screen->die("Config '$decoded' not owned by current user!");
1281         }
1282         # Make sure the file is not writable by other users. Doesn't handle
1283         # ACLs and see comment above about race conditions.
1284         my @stat = stat $path or die $!;
1285         my $mode = $stat[2];
1286         if (($mode & Fcntl::S_IWGRP) or ($mode & Fcntl::S_IWOTH)) {
1287             die "Config '$decoded' must not be writable by other users.";
1288         }
1289
1290         my $result = do $path;
1291         if (not $result) {
1292             $screen->die("Failed to parse '$decoded': $@") if $@;
1293             $screen->die("Failed to do '$decoded': $!") unless defined $result;
1294             $screen->die("Failed to run '$decoded'.");
1295         }
1296
1297         last; # success, don't load more files
1298     }
1299 }
1300 $screen->{debug} = $config{setting}{debug};
1301
1302
1303 # MAIN
1304
1305 eval {
1306     # Auto-detect current multiplexer.
1307     if (not defined $config{setting}{multiplexer}) {
1308         if (defined $ENV{STY} and defined $ENV{TMUX}) {
1309             die 'Found both $STY and $TMUX, set $config{setting}{multiplexer}.';
1310         } elsif (defined $ENV{STY}) {
1311             $config{setting}{multiplexer} = 'screen';
1312         } elsif (defined $ENV{TMUX}) {
1313             $config{setting}{multiplexer} = 'tmux';
1314         } else {
1315             die 'No multiplexer found.';
1316         }
1317     }
1318
1319     my $binmode = $encoding;
1320     # GNU screen stores the screen dump for unknown reasons as ISO-8859-1
1321     # instead of the currently active encoding.
1322     if ($config{setting}{multiplexer} eq 'screen') {
1323         $binmode = 'ISO-8859-1';
1324     }
1325
1326     my @input_lines;
1327     open my $fh, '<', $ARGV[0] or die $!;
1328     binmode $fh, ":encoding($binmode)" or die $!;
1329     while (<$fh>) {
1330         chomp;
1331         push @input_lines, $_;
1332     }
1333     close $fh or die $!;
1334
1335     my $input = prepare_input($screen, \@input_lines);
1336
1337     # Display original screen content.
1338     my $y = 0;
1339     foreach (@{$input->{lines}}) {
1340         $screen->draw_simple($y++, 0, undef, $_);
1341     }
1342     $screen->refresh;
1343
1344
1345     my $mapping = $config{setting}{initial_mode};
1346
1347     my $key;
1348     while (1) {
1349         if (not defined $mapping) {
1350             $key = $screen->getch unless defined $key;
1351             $screen->debug('input', "got key '$key'");
1352
1353             $mapping = $config{mapping}{mode}{$key};
1354             $mapping = $config{mapping}{simple}{$key} unless defined $mapping;
1355             if (not defined $mapping) { # ignore unknown mappings
1356                 $key = undef;
1357                 next;
1358             }
1359         }
1360
1361         $screen->debug('input', 'running mapping');
1362         my $result = $mapping->($key, $screen, \%config, $input);
1363         $mapping = undef;
1364
1365 RESULT:
1366         if (defined $result->{quit}) {
1367             $screen->debug('input', 'quitting');
1368             last;
1369         }
1370         if (defined $result->{key}) {
1371             $key = $result->{key}; # lookup another mapping
1372             $screen->debug('input', "processing new key: '$key'");
1373             next;
1374         }
1375         if (defined $result->{select}) {
1376             $screen->debug('input', 'selecting match');
1377             my $tmp = $result;
1378             $result = select_match($result->{select},
1379                                 $screen, \%config, $input,
1380                                 $result->{matches});
1381             $result->{handler} = $tmp->{handler};
1382             $result->{extend}  = $tmp->{extend};
1383             goto RESULT; # reprocess special entries in result
1384         }
1385         if (defined $result->{extend}) {
1386             $screen->debug('input', 'extending match');
1387             $result = extend_match($screen, \%config, $input,
1388                                    $result->{match});
1389             goto RESULT; # reprocess special entries in result
1390         }
1391         if (defined $result->{match}) {
1392             if (not defined $result->{match}{value}) {
1393                 $result->{match}{value} = $result->{match}{string};
1394             }
1395
1396             $screen->debug('input', 'running handler');
1397
1398             # Choose handler with falling priority.
1399             my @handlers = (
1400                 $config{state}{handler},     # set by user
1401                 $result->{match}{handler},   # set by match
1402                 $result->{handler},          # set by mapping
1403                 $config{handler}{yank},      # fallback
1404             );
1405             foreach my $handler (@handlers) {
1406                 next unless defined $handler;
1407
1408                 $handler->($screen, \%config, $result->{match});
1409                 last;
1410             }
1411             last;
1412         }
1413
1414         $key = undef; # get next key from user
1415     }
1416 };
1417 if ($@) {
1418     $screen->die("$@");
1419 }
1420
1421 $screen->deinit;
1422
1423 __END__
1424
1425 =head1 EXIT STATUS
1426
1427 =over 4
1428
1429 =item B<0>
1430
1431 Success.
1432
1433 =item B<1>
1434
1435 An error occurred.
1436
1437 =item B<2>
1438
1439 Invalid arguments/options.
1440
1441 =back
1442
1443 =head1 AUTHOR
1444
1445 Simon Ruderich E<lt>simon@ruderich.orgE<gt>
1446
1447 =head1 LICENSE AND COPYRIGHT
1448
1449 Copyright (C) 2013-2016 by Simon Ruderich
1450
1451 This program is free software: you can redistribute it and/or modify
1452 it under the terms of the GNU General Public License as published by
1453 the Free Software Foundation, either version 3 of the License, or
1454 (at your option) any later version.
1455
1456 This program is distributed in the hope that it will be useful,
1457 but WITHOUT ANY WARRANTY; without even the implied warranty of
1458 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1459 GNU General Public License for more details.
1460
1461 You should have received a copy of the GNU General Public License
1462 along with this program.  If not, see E<lt>http://www.gnu.org/licenses/E<gt>.
1463
1464 =head1 SEE ALSO
1465
1466 L<screen(1)>, L<tmux(1)>, L<urlview(1)>
1467
1468 =cut