=head1 USAGE
+Short overview of the general usage, details below:
+
+ - start fcscs
+ - configure actions (optional)
+ - enable pasting
+ - ...
+ - select mode (optional, URL mode is used on startup):
+ - f: file paths
+ - i: IPs
+ - u: URLs
+ - c: checksums (e.g. MD5, SHA1, ..)
+ - ...
+ - /: search mode
+ - for `normal' modes:
+ - select match by displayed number or <return> for lowest numbered
+ match
+ - configured action is run, e.g. URL is opened with browser
+ - for `search' mode:
+ - perform incremental search
+ - on <return> go to `normal' mode to select a match
+ - after the match is selected wait for confirmation or extension
+ - confirmation: <return> run previously selected action
+ - extension: change match, e.g. select complete word or line
+
GNU Screen setup (add to F<~/.screenrc>):
bind ^B eval "hardcopy $HOME/.tmp/screen-fcscs" "screen fcscs $HOME/.tmp/screen-fcscs"
entered number.
Press return before entering a number to select the last (lowest numbered)
-match. To abort without selecting any match either use "q".
+match (underlined by default). To abort without selecting any match use "q".
To change the selection mode (e.g. paths, files, etc.) use one of the mappings
explained below. Per default URLs are selected, see options for a way to
change this.
+I<NOTE>: Opening URLs in the browser passes the URL via the command line which
+leaks URLs to other users on the current system via C<ps aux> or C<top>.
+
I<NOTE>: When yanking (copying) a temporary file is used to pass the data to
-GNU screen/Tmux without exposing it to C<ps ux> or C<top>. However this may
+GNU screen/Tmux without exposing it to C<ps aux> or C<top>. However this may
leak data if those temporary files are written to disk. To prevent this change
-your C<$TMP> accordingly to point to a memory-only location or encrypted
-storage.
+your C<$TMP> to point to a memory-only location or encrypted storage.
If no window appears, try running B<fcscs> manually to catch the error message
and please report the bug:
sub draw_prompt {
my ($self, $config) = @_;
+ $self->debug('draw_prompt', 'started');
+
my $x = 0;
my $y = $self->height - 1;
# Draw prompt flags.
if (defined (my $s = $self->{prompt}{flags})) {
$s = "[$s]";
+ $self->debug('draw_prompt', $s);
$self->draw_clipped($y, $x, $config->{attribute}{prompt_flags}, $s);
$x += length($s) + 1; # space between next element
}
# Draw prompt name.
if (defined (my $s = $self->{prompt}{name})) {
$s = "[$s]";
+ $self->debug('draw_prompt', $s);
$self->draw_clipped($y, $x, $config->{attribute}{prompt_name}, $s);
$x += length($s) + 1;
}
# Draw prompt value, e.g. a search field.
if (defined (my $s = $self->{prompt}{value})) {
+ $self->debug('draw_prompt', $s);
$self->draw_clipped($y, $x, undef, $s);
$x += length($s) + 1;
}
my $attr_id = $config->{attribute}{match_id};
my $attr_string = $config->{attribute}{match_string};
+ my $attr_last = $config->{attribute}{match_last};
foreach (@{$matches_add}) {
- $self->draw($_->{y}, $_->{x}, $attr_string, $_->{string});
+ my $attr = (defined $_->{id} and $_->{id} == 1)
+ ? $attr_last
+ : $attr_string;
+ $self->draw($_->{y}, $_->{x}, $attr, $_->{string});
if (defined $_->{id}) {
$self->draw($_->{y}, $_->{x}, $attr_id, $_->{id});
}
$self->deinit;
exit 1;
}
+ sub debug {
+ my ($self, $module, @args) = @_;
+
+ return if not $self->{debug};
+
+ state $fh; # only open the file once per run
+ if (not defined $fh) {
+ # Ignore errors if the directory doesn't exist.
+ if (not open $fh, '>', "$ENV{HOME}/.config/fcscs/log") {
+ $fh = undef; # a failed open still writes a value to $fh
+ return;
+ }
+ $fh->autoflush(1);
+ }
+
+ foreach (@args) {
+ $_ = $self->encode($_);
+ }
+ say $fh "$module: @args" or CORE::die $!;
+ return;
+ }
sub prompt {
# FUNCTIONS
-sub debug {
- my ($config, $module, @args) = @_;
-
- return if not $config->{setting}{debug};
-
- state $fh; # only open the file once per run
- if (not defined $fh) {
- # Ignore errors if the directory doesn't exist.
- if (not open $fh, '>', "$ENV{HOME}/.config/fcscs/log") {
- $fh = undef; # a failed open still writes a value to $fh
- return;
- }
- }
-
- say $fh "$module: @args";
- return;
-}
-
-
sub prepare_input {
my ($screen, $input_ref) = @_;
sub run_command {
- my ($config, $cmd) = @_;
+ my ($screen, $cmd) = @_;
- debug $config, 'run_command', "running @{$cmd}";
+ $screen->debug('run_command', "running @{$cmd}");
my $exit = do {
# Perl's system() combined with a $SIG{__WARN__} which die()s has
# a working $$.
no warnings;
- system { $cmd->[0] } @{$cmd};
+ my @cmd = map { $screen->encode($_) } @{$cmd};
+ system { $cmd[0] } @cmd;
};
if ($exit != 0) {
my $msg;
return;
}
sub run_in_background {
- my ($config, $sub) = @_;
+ my ($screen, $sub) = @_;
- debug $config, 'run_in_background', "running $sub";
+ $screen->debug('run_in_background', "running $sub");
my $pid = fork;
defined $pid or die $!;
# closes the window (because the parent process has exited).
local $SIG{HUP} = 'IGNORE';
- # Necessary for GNU screen or it'll keep the window open until the
- # paste command has run.
- close STDIN or die $!;
- close STDOUT or die $!;
- close STDERR or die $!;
+ # Necessary for GNU screen or it'll keep the window open until an
+ # external command has run.
+ require File::Spec;
+ my $devnull = File::Spec->devnull();
+ open STDIN, '<', $devnull or die $!;
+ open STDOUT, '>', $devnull or die $!;
+ open STDERR, '>', $devnull or die $!;
# Double-fork to prevent zombies.
my $pid = fork;
sub select_match {
my ($name, $screen, $config, $input, $matches) = @_;
- debug $config, 'select_match', 'started';
+ $screen->debug('select_match', 'started');
return if @{$matches} == 0;
# Don't return on initial run to give the user a chance to select another
# mode, e.g. to switch from URL selection to search selection.
- if (@{$matches} == 1 and not $config->{state}->{initial}) {
+ if (@{$matches} == 1 and not $config->{state}{initial}) {
return { match => $matches->[0] };
}
$config->{state}{initial} = 0;
$number = $number * 10 + $char;
} elsif ($char eq "\b" or $char eq "\x7f") { # backspace
$number = int($number / 10);
- } elsif ($char eq "\n") {
- if ($number == 0) { # number without selection matches last entry
- $number = 1;
- }
+ } elsif ($char eq "\n"
+ or $char eq $config->{setting}{alternative_return}) {
last;
# Selecting a new mode requires falling through into the main input
return { key => $char };
# All other mappings stay in the current mode.
} elsif (defined (my $m = $config->{mapping}{simple}{$char})) {
- $m->($char, $screen, $config, $input);
+ my $result = $m->($char, $screen, $config, $input);
+ last if defined $result->{select_match};
next;
} else {
$screen->draw_matches($config, $matches, \@remaining);
$screen->refresh;
}
+ # Number without selection matches last entry.
+ if ($number == 0) {
+ $number = 1;
+ }
$screen->draw_matches($config, $matches, []); # remove matches
foreach (@{$matches}) {
return { match => $_ } if $_->{id} == $number;
}
- debug $config, 'select_match', 'no match selected';
+ $screen->debug('select_match', 'no match selected');
return { match => undef };
}
sub extend_match {
my ($screen, $config, $input, $match) = @_;
- debug $config, 'extend_match', 'started';
+ $screen->debug('extend_match', 'started');
+
+ return if not defined $match;
$screen->prompt(name => 'extend', value => undef);
$screen->draw_prompt($config);
my $match_old = \%{$match};
my $char = $screen->getch;
- if ($char eq "\n") { # accept match
- last;
+ if ($char eq "\n"
+ or $char eq $config->{setting}{alternative_return}) {
+ last; # accept match
} elsif ($char eq 'w') { # select current word (both directions)
extend_match_regex_left($line, $match, qr/\w+/);
} elsif ($char eq 'E') { # select current WORD (only right)
extend_match_regex_right($line, $match, qr/\S+/);
- } elsif ($char eq '^') { # select to beginning of line
+ } elsif ($char eq '0') { # select to beginning of line
extend_match_regex_left($line, $match, qr/.+/);
} elsif ($char eq '$') { # select to end of line
extend_match_regex_right($line, $match, qr/.+/);
$screen->refresh;
}
- debug $config, 'extend_match', 'done';
+ $screen->debug('extend_match', 'done');
return { match => $match };
}
-sub mapping_paste {
- my ($key, $screen, $config, $input) = @_;
+sub mapping_state_helper {
+ my ($name, $flags, $key, $screen, $config, $input) = @_;
- debug $config, 'mapping_paste', 'started';
+ $screen->debug("mapping_$name", 'started');
- $config->{state}{handler} = $config->{handler}{paste};
+ $config->{state}{handler} = $config->{handler}{$name};
- $screen->prompt(flags => 'P'); # paste
+ $screen->prompt(flags => $flags);
$screen->draw_prompt($config);
$screen->refresh;
return {};
}
-sub mapping_yank {
- my ($key, $screen, $config, $input) = @_;
+sub mapping_state_now_helper {
+ my ($name, $key, $screen, $config, $input) = @_;
- debug $config, 'mapping_yank', 'started';
+ $screen->debug("mapping_${name}_now", 'started');
- $config->{state}{handler} = $config->{handler}{yank};
+ $config->{state}{handler} = $config->{handler}{$name};
- $screen->prompt(flags => 'Y'); # yank
- $screen->draw_prompt($config);
- $screen->refresh;
+ return {
+ select_match => 1,
+ };
+}
- return {};
+sub mapping_paste {
+ return mapping_state_helper('paste', 'P', @_);
+}
+sub mapping_paste_now {
+ return mapping_state_now_helper('paste', @_);
+}
+
+sub mapping_yank {
+ return mapping_state_helper('yank', 'Y', @_);
+}
+sub mapping_yank_now {
+ return mapping_state_now_helper('yank', @_);
}
=over 4
-=item B<path mode> select relative/absolute paths
+=item B<path mode> select relative/absolute paths
+
+=item B<url mode> select URLs
+
+=item B<ip mode> select IPv4 and IPv6 addresses
-=item B<url mode> select URLs
+=item B<checksum mode> select checksums (MD5, SHA1, SHA256, SHA512)
=back
=cut
-sub mapping_mode_path {
- my ($key, $screen, $config, $input) = @_;
+sub mapping_mode_helper {
+ my ($name, $select, $key, $screen, $config, $input) = @_;
- debug $config, 'mapping_mode_path', 'started';
+ $screen->debug("mapping_mode_$name", 'started');
- my @matches = get_regex_matches($input, $config->{regex}{path});
+ my @matches = get_regex_matches($input, $config->{regex}{$name});
return {
- select => 'path select',
+ select => $select,
matches => \@matches,
- handler => $config->{handler}{yank},
+ handler => $config->{handler}{$name},
};
}
+sub mapping_mode_path {
+ return mapping_mode_helper('path', 'path select', @_);
+}
sub mapping_mode_url {
+ return mapping_mode_helper('url', 'url select', @_);
+}
+sub mapping_mode_ip {
my ($key, $screen, $config, $input) = @_;
- debug $config, 'mapping_mode_url', 'started';
+ $screen->debug('mapping_mode_ip', 'started');
- my @matches = get_regex_matches($input, $config->{regex}{url});
+ my @ipv4 = get_regex_matches($input, $config->{regex}{ipv4});
+ my @ipv6 = get_regex_matches($input, $config->{regex}{ipv6});
return {
- select => 'url select',
- matches => \@matches,
- handler => $config->{handler}{url},
+ select => 'ip select',
+ matches => [@ipv4, @ipv6],
+ handler => $config->{handler}{ip},
};
}
+sub mapping_mode_checksum {
+ return mapping_mode_helper('checksum', 'checksum select', @_);
+}
=head2 SEARCH MODE (AND EXTEND MODE)
=item B<E> extend WORD to the right
-=item B<^> extend to beginning of line
+=item B<0> extend to beginning of line
=item B<$> extend to end of line
sub mapping_mode_search {
my ($key, $screen, $config, $input) = @_;
- debug $config, 'mapping_mode_search', 'started';
+ $screen->debug('mapping_mode_search', 'started');
$screen->cursor(1);
$screen->cursor(0);
+ $screen->prompt(name => undef, value => undef); # clear prompt
+ $screen->draw_prompt($config);
+
+ $screen->debug('mapping_mode_search', 'done');
+
return {
select => 'search',
matches => \@last_matches,
sub handler_yank {
my ($screen, $config, $match) = @_;
- debug $config, 'handler_yank', 'started';
+ $screen->debug('handler_yank', 'started');
require File::Temp;
# Use a temporary file to prevent leaking the yanked data to other users
# with the command line, e.g. ps aux or top.
my ($fh, $tmp) = File::Temp::tempfile(); # dies on its own
- print $fh $screen->encode($match->{value});
+ print $fh $screen->encode($match->{value}) or die $!;
close $fh or die $!;
if ($config->{setting}{multiplexer} eq 'screen') {
- debug $config, 'handler_yank', 'using screen';
+ $screen->debug('handler_yank', 'using screen');
# GNU screen displays an annoying "Slurping X characters into buffer".
# Use 'msgwait 0' as a hack to disable it.
my $msgwait = $config->{setting}{screen_msgwait};
- run_command($config, ['screen', '-X', 'msgwait', 0]);
- run_command($config, ['screen', '-X', 'readbuf', $tmp]);
- run_command($config, ['screen', '-X', 'msgwait', $msgwait]);
+ run_command($screen, ['screen', '-X', 'msgwait', 0]);
+ run_command($screen, ['screen', '-X', 'readbuf', $tmp]);
+ run_command($screen, ['screen', '-X', 'msgwait', $msgwait]);
} elsif ($config->{setting}{multiplexer} eq 'tmux') {
- debug $config, 'handler_yank', 'using tmux';
+ $screen->debug('handler_yank', 'using tmux');
- run_command($config, ['tmux', 'load-buffer', $tmp]);
+ run_command($screen, ['tmux', 'load-buffer', $tmp]);
} else {
die 'unsupported multiplexer';
}
unlink $tmp or die $!;
+
+ if ($config->{setting}{yank_x11}) {
+ $screen->debug('handler_yank', 'setting X11 selection');
+
+ my @xsel_cmd = qw( xsel --input --primary );
+ my @xclip_cmd = qw( xclip -in -selection primary );
+
+ my $fh;
+ {
+ # We don't care if a program doesn't exist.
+ no warnings;
+
+ if (not open $fh, '|-', @xsel_cmd) {
+ if (not open $fh, '|-', @xclip_cmd) {
+ die "install xsel or xlip to yank to X11 selection\n";
+ }
+ }
+ }
+ print $fh $match->{value} or die $!;
+ close $fh or die $!;
+ }
+
return;
}
sub handler_paste {
my ($screen, $config, $match) = @_;
- debug $config, 'handler_paste', 'started';
+ $screen->debug('handler_paste', 'started');
require Time::HiRes;
my @cmd;
if ($config->{setting}{multiplexer} eq 'screen') {
- debug $config, 'handler_paste', 'using screen';
+ $screen->debug('handler_paste', 'using screen');
@cmd = qw( screen -X paste . );
} elsif ($config->{setting}{multiplexer} eq 'tmux') {
- debug $config, 'handler_paste', 'using tmux';
+ $screen->debug('handler_paste', 'using tmux');
@cmd = qw( tmux paste-buffer );
} else {
die 'unsupported multiplexer';
}
- run_in_background($config, sub {
+ run_in_background($screen, sub {
# We need to get the data in the paste buffer before we can paste
# it.
handler_yank($screen, $config, $match);
# Sleep until we switch back to the current window.
Time::HiRes::usleep($config->{setting}{paste_sleep});
- run_command($config, \@cmd);
+ run_command($screen, \@cmd);
});
return;
}
sub handler_url {
my ($screen, $config, $match) = @_;
- debug $config, 'handler_url', "opening $match->{value}";
+ $screen->debug('handler_url', "opening $match->{value}");
- run_in_background($config, sub {
- my @cmd = map { $screen->encode($_) } (
- @{$config->{setting}{browser}},
- $match->{value},
- );
- run_command($config, \@cmd);
+ run_in_background($screen, sub {
+ my @cmd = ( @{$config->{setting}{browser}}, $match->{value} );
+ run_command($screen, \@cmd);
});
return;
}
# Draw matches in blue.
$config{attribute}{match_string} = color_pair(COLOR_BLUE, -1);
- # Enable Vim-like 'smartcase', ignore case until an upper character is
+ # Draw numbers in bold yellow.
+ $config{attribute}{match_id} = color_pair(COLOR_YELLOW, -1)
+ | A_BOLD;
+ # Disable Vim-like 'smartcase', ignore case until an upper character is
# searched.
- $config{setting}{smartcase} = 1;
+ $config{setting}{smartcase} = 0;
# Use chromium to open URLs if running under X, elinks otherwise.
if (defined $ENV{DISPLAY}) {
$config{setting}{browser} = ['chromium'];
} else {
- $config{setting}{browser} = ['elinks'];
+ $config{setting}{browser} = ['elinks', '-remote'];
}
# Let fcscs know the file was loaded successfully.
I<NOTE>: Mappings are split in two categories: Mode mappings which change the
selection and may receive additional input (e.g. a search string) and simple
-mappings which only change some value. Mode mappings are configured via
+mappings which only change some config value. Mode mappings are configured via
C<$config{mapping}{mode}>, simple mappings via C<$config{mapping}{simple}>.
The following mode mappings are available by default (the function to remap
=item B<u> select URLs (C<\&mapping_mode_url>)
+=item B<i> select IPv4 and IPv6 addresses (C<\&mapping_mode_ip>)
+
+=item B<c> select checksums (e.g. MD5, SHA) (C<\&mapping_mode_checksum>)
+
=item B</> search for regex to get selection (C<\&mapping_mode_search>)
=item B<q> quit fcscs (C<\&mapping_quit>)
=item B<p> enable pasting (C<\&mapping_paste>)
+=item B<P> paste current selection (like C<\n> but paste) (C<\&mapping_paste_now>)
+
=item B<y> enable yanking (copying) (C<\&mapping_yank>)
+=item B<Y> yank current selection (like C<\n> but yank) (C<\&mapping_yank_now>)
+
+=back
+
+Note that yanking only uses the GNU screen or Tmux paste buffer by default. To
+also copy to X11 selection, enable the B<yank_x11> option.
+
+The following additional mappings are available by default:
+
+=over
+
+=item B<\n> accept current selection (not customizable)
+
+=item B<s> additional key to accept selection (B<alternative_return> option)
+
=back
All (single-byte) keys except numbers, backspace and return can be mapped.
my %mapping_mode = (
f => \&mapping_mode_path,
u => \&mapping_mode_url,
+ i => \&mapping_mode_ip,
+ c => \&mapping_mode_checksum,
'/' => \&mapping_mode_search,
q => \&mapping_quit,
);
my %mapping_simple = (
p => \&mapping_paste,
+ P => \&mapping_paste_now,
y => \&mapping_yank,
+ Y => \&mapping_yank_now,
);
=head2 ATTRIBUTES
=item B<match_string> attribute for matches (yellow, default, normal)
+=item B<match_last> attribute for the match selected by return (yellow, default, underline)
+
=item B<prompt_name> attribute for prompt name (standout)
=item B<prompt_flags> attribute for prompt flags (standout)
match_id => $screen->color_pair(Curses::COLOR_RED, -1)
| Curses::A_BOLD,
match_string => $screen->color_pair(Curses::COLOR_YELLOW, -1),
+ match_last => $screen->color_pair(Curses::COLOR_YELLOW, -1)
+ | Curses::A_UNDERLINE,
prompt_name => Curses::A_STANDOUT,
prompt_flags => Curses::A_STANDOUT,
);
=over
-=item B<debug> enable debug mode, writes to I<~/.config/fcscs/log> (C<0>)
+=item B<debug> enable debug mode, writes to I<~/.config/fcscs/log> (C<0>)
+
+=item B<initial_mode> start in this mode, must be a valid mode mapping (C<\&mapping_mode_url>)
+
+=item B<multiplexer> set multiplexer ("screen" or "tmux"), defaults to autodetection (C<undef>)
-=item B<initial_mode> start in this mode, must be a valid mode mapping (C<\&mapping_mode_url>)
+=item B<ignorecase> ignore case when searching (C<0>)
-=item B<multiplexer> set multiplexer ("screen" or "tmux") if not autodetected (C<undef>)
+=item B<smartcase> ignore case unless one uppercase character is searched (C<1>)
-=item B<ignorecase> ignore case when searching (C<0>)
+=item B<yank_x11> copy selection also to X11 primary selection when yanking (C<0>)
-=item B<smartcase> ignore case unless one uppercase character is searched (C<1>)
+=item B<paste_sleep> sleep x us before running paste command (C<100_000>)
-=item B<paste_sleep> sleep x us before running paste command (C<100_000>)
+=item B<screen_msgwait> GNU Screen's msgwait variable, used when yanking (C<5>)
-=item B<screen_msgwait> GNU Screen's msgwait variable, used when yanking (C<5>)
+=item B<alternative_return> additional accept key like return, set to C<\n> to disable (C<s>)
-=item B<browser> browser command as array reference (C<['x-www-browser']>)
+=item B<browser> browser command as array reference (C<['x-www-browser']>)
=back
=cut
my %setting = (
# options
- debug => 0,
- initial_mode => \&mapping_mode_url,
- multiplexer => undef,
- ignorecase => 0,
- smartcase => 1,
- paste_sleep => 100_000,
- screen_msgwait => 5,
+ debug => 0,
+ initial_mode => \&mapping_mode_url,
+ multiplexer => undef,
+ ignorecase => 0,
+ smartcase => 1,
+ yank_x11 => 0,
+ paste_sleep => 100_000,
+ screen_msgwait => 5,
+ # global mappings
+ alternative_return => 's',
# commands
- browser => ['x-www-browser'],
+ browser => ['x-www-browser'],
);
=head2 REGEXPS
=over
-=item B<url> used by C<\&mapping_mode_url()>
+=item B<url> used by C<\&mapping_mode_url>
-=item B<path> used by C<\&mapping_mode_path()>
+=item B<path> used by C<\&mapping_mode_path>
+
+=item B<ipv4> used by C<\&mapping_mode_ip>
+
+=item B<ipv6> used by C<\&mapping_mode_ip>
=back
# Taken from urlview's default configuration file, thanks.
url => qr{((?:(?:(?:http|https|ftp|gopher)|mailto):(?://)?[^ <>"\t]*|(?:www|ftp)[0-9]?\.[-a-z0-9.]+)[^ .,;\t\n\r<">\):]?[^, <>"\t]*[^ .,;\t\n\r<">\):])},
path => qr{(~?[a-zA-Z0-9_./-]*/[a-zA-Z0-9_./-]+)},
+ # IP addresses with optional prefix. Not perfectly accurate but good
+ # enough.
+ ipv4 => qr!\b(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(?:/\d{1,2})?)\b!,
+ ipv6 => qr!\b((?:[0-9a-fA-F]{1,4})?(?::+[0-9a-fA-F]{1,4})+(?:/\d{1,3})?)\b!,
+ # MD5, SHA1, SHA256, SHA512
+ checksum => qr!\b([0-9a-fA-F]{32}|[0-9a-fA-F]{40}|[0-9a-fA-F]{64}|[0-9a-fA-F]{128})\b!,
);
=head2 HANDLERS
=over
-=item B<yank> used to yank (copy) selection to paste buffer (C<\&handler_yank>)
+=item B<yank> used to yank (copy) selection to paste buffer (C<\&handler_yank>)
+
+=item B<paste> used to paste selection into window (C<\&handler_paste>)
-=item B<paste> used to paste selection into window (C<\&handler_paste>)
+=item B<path> used to handle paths (C<\&handler_yank>)
-=item B<url> used to open URLs (e.g. in a browser) (C<\&handler_url>)
+=item B<url> used to open URLs (e.g. in a browser) (C<\&handler_url>)
+
+=item B<ip> used to handle IPs (C<\&handler_yank>)
+
+=item B<checksum> used to handle checksums (C<\&handler_yank>)
=back
my ($screen, $config, $match) = @_;
if ($match->{value} =~ m{^https://www.youtube.com/}) {
- return run_in_background($config, sub {
- run_command($config, ['youtube-dl-wrapper', $match->{value}]);
+ return run_in_background($screen, sub {
+ run_command($screen, ['youtube-dl-wrapper', $match->{value}]);
});
}
handler_url(@_);
=cut
my %handler = (
- yank => \&handler_yank,
- paste => \&handler_paste,
- url => \&handler_url,
+ yank => \&handler_yank,
+ paste => \&handler_paste,
+ path => \&handler_yank,
+ url => \&handler_url,
+ ip => \&handler_yank,
+ checksum => \&handler_yank,
);
my %state = (
mapping_mode_path()
mapping_mode_url()
+ mapping_mode_ip()
+ mapping_mode_checksum()
mapping_mode_search()
mapping_paste()
+ mapping_paste_now()
mapping_yank()
+ mapping_yank_now()
mapping_quit()
Used as mappings, see L</MAPPINGS> above.
Used as handler to yank, paste selection or open URL in browser.
- debug()
get_regex_matches()
select_match()
run_command()
run_in_background()
-Helper functions when writing custom mappings, see the source for details.
+Helper functions when writing custom mappings, see the source and example for
+details.
Example:
- TODO
+ # Enhance URL mode by updating the mapping.
+ $config{mapping}{mode}{u} = sub {
+ my ($key, $screen, $config, $input) = @_;
+
+ # First get matches of normal URL mode.
+ my $result = mapping_mode_url(@_);
+
+ # Add all strings matching "CVE-1234-1234" with URLs pointing to the
+ # Debian security tracker. "->{value}" is the string which is used as
+ # result of the match (e.g. the URL in this case).
+ my @matches = get_regex_matches($input, qr/\b(CVE-\d+-\d+)\b/);
+ foreach (@matches) {
+ $_->{value} = "https://security-tracker.debian.org/$_->{string}";
+ }
+ push @{$result->{matches}}, @matches;
+
+ # Change all YouTube links to use the custom "youtube" handler (see
+ # below). This will allow us to automatically open YouTube URLs with a
+ # custom program, like `youtube-dl` or `mpv`.
+ foreach (@{$result->{matches}}) {
+ if ($_->{string} =~ m{^https://www.youtube.com/}) {
+ $_->{handler} = $config{handler}{youtube};
+ }
+ }
+
+ return $result;
+ };
+ # Also update initial mode to use our new "URL mode".
+ $config{setting}{initial_mode} = $config{mapping}{mode}{u};
+
+ # Special handler to download YouTube URLs with `youtube-dl`. You could
+ # also use `mpv` here to immediately play them.
+ $config{handler}{youtube} = sub {
+ my ($screen, $config, $match) = @_;
+
+ return run_in_background($screen, sub {
+ run_command($screen, ['youtube-dl', $match->{value}]);
+ });
+ };
=cut
sub mapping_mode_path { return main::mapping_mode_path(@_); }
sub mapping_mode_url { return main::mapping_mode_url(@_); }
+ sub mapping_mode_ip { return main::mapping_mode_ip(@_); }
+ sub mapping_mode_checksum { return main::mapping_mode_checksum(@_); }
sub mapping_mode_search { return main::mapping_mode_search(@_); }
sub mapping_paste { return main::mapping_paste(@_); }
+ sub mapping_paste_now { return main::mapping_paste_now(@_); }
sub mapping_yank { return main::mapping_yank(@_); }
+ sub mapping_yank_now { return main::mapping_yank_now(@_); }
sub mapping_quit { return main::mapping_quit(@_); }
sub handler_yank { return main::handler_yank(@_); }
sub handler_paste { return main::handler_paste(@_); }
sub handler_url { return main::handler_url(@_); }
- sub debug { return main::debug(@_); }
-
sub get_regex_matches { return main::get_regex_matches(@_); }
sub select_match { return main::select_match(@_); }
}
# Make sure the file is not writable by other users. Doesn't handle
# ACLs and see comment above about race conditions.
- my @stat = stat $path or die $!;
+ my @stat = stat $path or $screen->die("Config '$decoded': $!");
my $mode = $stat[2];
if (($mode & Fcntl::S_IWGRP) or ($mode & Fcntl::S_IWOTH)) {
- die "Config '$decoded' must not be writable by other users.";
+ $screen->die("Config '$decoded' must not be writable by other users.");
}
my $result = do $path;
while (1) {
if (not defined $mapping) {
$key = $screen->getch unless defined $key;
- debug \%config, 'input', "got key '$key'";
+ $screen->debug('input', "got key '$key'");
$mapping = $config{mapping}{mode}{$key};
$mapping = $config{mapping}{simple}{$key} unless defined $mapping;
}
}
- debug \%config, 'input', 'running mapping';
+ $screen->debug('input', 'running mapping');
my $result = $mapping->($key, $screen, \%config, $input);
$mapping = undef;
RESULT:
if (defined $result->{quit}) {
- debug \%config, 'input', 'quitting';
+ $screen->debug('input', 'quitting');
last;
}
if (defined $result->{key}) {
$key = $result->{key}; # lookup another mapping
- debug \%config, 'input', "processing new key: '$key'";
+ $screen->debug('input', "processing new key: '$key'");
next;
}
if (defined $result->{select}) {
- debug \%config, 'input', 'selecting match';
+ $screen->debug('input', 'selecting match');
my $tmp = $result;
$result = select_match($result->{select},
- $screen, \%config, $input,
- $result->{matches});
+ $screen, \%config, $input,
+ $result->{matches});
$result->{handler} = $tmp->{handler};
$result->{extend} = $tmp->{extend};
goto RESULT; # reprocess special entries in result
}
if (defined $result->{extend}) {
- debug \%config, 'input', 'extending match';
+ $screen->debug('input', 'extending match');
$result = extend_match($screen, \%config, $input,
$result->{match});
goto RESULT; # reprocess special entries in result
}
if (defined $result->{match}) {
- if (not defined $result->{match}->{value}) {
- $result->{match}->{value} = $result->{match}->{string};
+ if (not defined $result->{match}{value}) {
+ $result->{match}{value} = $result->{match}{string};
}
- debug \%config, 'input', 'running handler';
+ $screen->debug('input', 'running handler');
# Choose handler with falling priority.
my @handlers = (
$config{state}{handler}, # set by user
- $result->{match}->{handler}, # set by match
+ $result->{match}{handler}, # set by match
$result->{handler}, # set by mapping
$config{handler}{yank}, # fallback
);
ruderich.org/simon / fcscs / fcscs.git / blobdiff