File Coverage

blib/lib/Term/ReadLine/Zoid/ViCommand.pm

Criterion	Covered	Total	%
statement	153	178	85.9
branch	53	80	66.2
condition	21	26	80.7
subroutine	25	29	86.2
pod	1	20	5.0
total	253	333	75.9

package Term::ReadLine::Zoid::ViCommand;

use strict;
use vars '$AUTOLOAD';
no strict 'refs';
use AutoLoader;
use base 'Term::ReadLine::Zoid';
no warnings; # undef == '' down here

our $VERSION = 0.05;

sub AUTOLOAD { # more intelligent inheritance
	my $sub = $AUTOLOAD;
	$sub =~ s/.*:://;
	my $m = $_[0]->can($sub) ? 'AutoLoader' : 'Term::ReadLine::Zoid';
	${$m.'::AUTOLOAD'} = $AUTOLOAD;
	goto &{$m.'::AUTOLOAD'};
}

=head1 NAME

Term::ReadLine::Zoid::ViCommand - a readline command mode

=head1 SYNOPSIS

This class is used as a mode under L,
see there for usage details.

=head1 DESCRIPTION

This mode provides a "vi command mode" as specified by the posix spec for the sh(1)
utility. It intends to include at least all key-bindings
mentioned by the posix spec for the vi mode in sh(1).
It also contains some extensions borrowed from vim(1) and some private extensions.

This mode has a "kill buffer" that stores the last killed text so it can
be yanked again. This buffer has only one value, it isn't a "kill ring".

=head1 KEY MAPPING

Since ViCommand inherits from MultiLine, which in turn inherits
from Term::ReadLine::Zoid, key bindings are also inherited unless explicitly overloaded.

Control-d is ignored in this mode.

=over 4

=cut

our %_keymap = (
	return  => 'accept_line',
	ctrl_D	=> 'bell',
	ctrl_Z	=> 'sigtstp',
	backspace => 'backward_char',
	escape	=> 'vi_reset',
	ctrl_A	=> 'vi_increment',
	ctrl_X	=> 'vi_increment',
	_on_switch => 'vi_switch',
	_isa	=> 'multiline', # but wait .. self_insert is overloaded
);

sub keymap { return \%_keymap }

sub vi_switch {
	my $self = shift;
	return $$self{_loop} = undef if $$self{_vi_mini_b};
	$$self{vi_command}   = '';
	$$self{vi_history} ||= [];
	$self->backward_char unless $_[1] or $$self{pos}[0] == 0;
}

our @vi_motions = (' ', ',', qw/0 b F l W ^ $ ; E f T w | B e h t/);
our %vi_subs = (
	'#'  => 'vi_comment',		'='  => 'vi_complete',
	'\\' => 'vi_complete',		'*'  => 'vi_complete',
	'@'  => 'vi_macro',		'~'  => 'vi_case',
	'.'  => 'vi_repeat',		' '  => 'forward_char',
	'^'  => 'vi_home',		'$'  => 'end_of_line',
	'0'  => 'beginning_of_line',	'|'  => 'vi_cursor',
	';'  => 'vi_c_repeat',		','  => 'vi_c_repeat',
	'_'  => 'vi_topic',		'-'  => 'vi_K',
	'+'  => 'vi_J',

	'l'  => 'forward_char',		'h' => 'backward_char',
	't'  => 'vi_F',			'T' => 'vi_F',
);
our %vi_commands = (
	'/' => 'bsearch',
	'?' => 'fsearch',
	'!' => 'shell',
	'q' => 'quit',
);

sub self_insert {
	my ($self, $key) = @_;

	if (length($key) > 1) { # no vague chars
		$self->bell;
		$$self{vi_command} = '';
	}
	else { $$self{vi_command} .= $key }

	if ($$self{vi_command} =~ /^[\/\?\:]/) {
		$self->vi_mini_buffer($key)
	}
	elsif ($$self{vi_command} =~ /^0|^(\d*)(\D)/) { # this is where a command gets executed
		my ($cnt, $cmd) = ($1||1, $2||'0');
		my $sub = $vi_subs{$cmd} || 'vi_'.uc($cmd);
		#print STDERR "string: $$self{vi_command} cnt: $cnt sub: $sub\n";
		my $r;
		if ($self->can($sub)) {
			my $s = $self->save();
			$r = $self->$sub($cmd, $cnt); # key, count
			push @{$$self{undostack}}, $s unless lc($cmd) eq 'u'
				or join("\n", @{$$s{lines}}) eq join("\n", @{$$self{lines}});
		}
		else { $self->bell() }
		$$self{vi_last_cmd} = $$self{vi_command}
			if $$self{vi_command} && ! grep( {$_ eq $cmd} @vi_motions, '.'); # for repeat ('.')
		$$self{vi_command} = '';
		#print STDERR "return: $r vi_last_cmd: $$self{vi_last_cmd}\n";
		return $r;
	}
	else {
		return if $$self{vi_command} =~ /^\d+$/;
		#print STDERR "string: $$self{vi_command} rejected\n";
		$self->bell;
		$$self{vi_command} = '';
	}
	return 0;
}

# ############ #
# Key bindings #
# ############ #

# Subs get args ($self, $key, $count)

sub vi_reset { $_[0]{vi_command} = ''; return 0 }

sub sigtstp { kill 20, $$ } # SIGTSTP

=item escape

Reset the command mode.

=item return

=item ^J

Return the current edit line to the application for execution.

=item ^Z

Send a SIGSTOP to the process of the application. Might not work when the application
ignores those, which is something shells tend to do.

=item i

Switch back to insert mode.

=item I

Switch back to insert mode at the begin of the edit line.

=item a

Enter insert mode after the current cursor position.

=item A

Enter insert mode at the end of the edit line.

=cut

sub vi_I {
	$_[0]{pos}[0] = 0 if $_[1] eq 'I';
	$_[0]->switch_mode();
}

sub vi_A {
	($_[1] eq 'A') ? $_[0]->end_of_line : $_[0]->forward_char ;
	$_[0]->switch_mode();
}

=item m

Switch to multiline insert mode, see L.
(private extension)

=item M

Switch to multiline insert mode at the end of the edit buffer.
(private extension)

=cut

sub vi_M {
	if ($_[1] eq 'M') {
		$_[0]{pos}[1] = $#{$_[0]{lines}};
		$_[0]->end_of_line;
	}
	else { $_[0]->forward_char }
	$_[0]->switch_mode('multiline')
}

=item R

Enter insert mode with replace toggled on.
(vim extension)

=cut

sub vi_R {
	my $self = shift;
	return $self->vi_r(@_) if $_[0] eq 'r';
	$self->switch_mode();
	$$self{replace} = 1;
}

## more bindings are defined in __END__ section for autosplit ##

__END__