Result:
found more than 465 distributions - search limited to the first 2001 files matching your query
( run in 0.995 )
App-VTide
view release on metacpan or search on metacpan
lib/App/VTide/Command/Split.pm view on Meta::CPAN
-v --verbose Show environment as well as config
--help Show this help
--man Show the full man page
Examples
# split the screen horizontally (keep cursor on initial screen)
vtide split h
# split the screen horizontally (move cursor to new screen)
vtide split H
=head1 DESCRIPTION
=head1 SUBROUTINES/METHODS
App-Widget
view release on metacpan or search on metacpan
lib/App/Widget/HierSelector.pm view on Meta::CPAN
# {node}{number}{open} # 1=open 0=closed
# {node}{number}{value} #
# {node}{number}{label} #
# {node}{number}{icon} # icon to use (default, closed)
# {node}{number}{openicon} # icon to use when open (optional)
# {node}{number}{hovericon} # icon to use when cursor over icon
# INPUTS FROM THE ENVIRONMENT
=head1 DESCRIPTION
App-YTDL
view release on metacpan or search on metacpan
lib/App/YTDL/Download.pm view on Meta::CPAN
use 5.010000;
use Exporter qw( import );
our @EXPORT_OK = qw( download );
use Term::ANSIScreen qw( :cursor :screen );
use Term::Choose qw( choose );
use App::YTDL::Helper qw( HIDE_CURSOR SHOW_CURSOR uni_system );
END { print SHOW_CURSOR }
App-ZFSCurses
view release on metacpan or search on metacpan
lib/App/ZFSCurses/Text.pm view on Meta::CPAN
sub footer {
my $self = shift;
my $f1 = shift;
my $help =
"[Up/Down] Move cursor up/down. "
. "[Enter/Space] Validate. "
. "[Tab] Change focus. "
. "\n[Ctrl+q] Quit. ";
if ( defined $f1 ) { $help .= "$f1"; }
return $help;
App-ZodiacUtils
view release on metacpan or search on metacpan
script/_chinese-zodiac-of view on Meta::CPAN
# v => 1.1,
# summary => 'Return line with point marked by a marker',
# description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
script/_chinese-zodiac-of view on Meta::CPAN
# description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
# position of cursor, for example (`^` marks the position of cursor):
# `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
# doing tab completion.
#
#_
# schema => 'hash*',
script/_chinese-zodiac-of view on Meta::CPAN
# # this is a workaround. since bash breaks words using characters in
# # $COMP_WORDBREAKS, which by default is "'@><=;|&(: this presents a problem
# # we often encounter: if we want to provide with a list of strings
# # containing say ':', most often Perl modules/packages, if user types e.g.
# # "Text::AN" and we provide completion ["Text::ANSI"] then bash will change
# # the word at cursor to become "Text::Text::ANSI" since it sees the current
# # word as "AN" and not "Text::AN". the workaround is to chop /^Text::/ from
# # completion answers. btw, we actually chop /^text::/i to handle
# # case-insensitive matching, although this does not have the ability to
# # replace the current word (e.g. if we type 'text::an' then bash can only
# # replace the current word 'an' with 'ANSI).
script/_chinese-zodiac-of view on Meta::CPAN
# % somecmd t<Tab>
# two three
#
#Another source is from a bash function (C<-F>). The function will receive input
#in two variables: C<COMP_WORDS> (array, command-line chopped into words) and
#C<COMP_CWORD> (integer, index to the array of words indicating the cursor
#position). It must set an array variable C<COMPREPLY> that contains the list of
#possible completion:
#
# % _foo()
# {
script/_chinese-zodiac-of view on Meta::CPAN
# % foo <Tab>
# --help --verbose --version
#
#And yet another source is an external command (C<-C>) including, from a Perl
#script. The command receives two environment variables: C<COMP_LINE> (string,
#raw command-line) and C<COMP_POINT> (integer, cursor location). Program must
#split C<COMP_LINE> into words, find the word to be completed, complete that, and
#return the list of words one per-line to STDOUT. An example:
#
# % cat foo-complete
# #!/usr/bin/perl
script/_chinese-zodiac-of view on Meta::CPAN
#Optional. Known options:
#
#=over
#
#=item * C<truncate_current_word> (bool). If set to 1, will truncate current word to the
#position of cursor, for example (C<^> marks the position of cursor):
#C<--vers^oo> to C<--vers> instead of C<--versoo>. This is more convenient when
#doing tab completion.
#
#=back
#
script/_chinese-zodiac-of view on Meta::CPAN
# point($cmdline, $marker) -> any
#
#Return line with point marked by a marker.
#
#This is a utility function useful for testing/debugging. C<parse_cmdline()>
#expects a command-line and a cursor position (C<$line>, C<$point>). This routine
#expects C<$line> with a marker character (by default it's the caret, C<^>) and
#return (C<$line>, C<$point>) to feed to C<parse_cmdline()>.
#
#Example:
#
script/_chinese-zodiac-of view on Meta::CPAN
#single dash will be completed. For example if you have `-foo=s` in your option
#specification, `-f<tab>` can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like `-nw`, `-nbc` etc (but also have double-dash options like
#`--no-window-system` or `--no-blinking-cursor`).
#
#_
# },
# },
# result_naked => 1,
script/_chinese-zodiac-of view on Meta::CPAN
#single dash will be completed. For example if you have C<-foo=s> in your option
#specification, C<< -fE<lt>tabE<gt> >> can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like C<-nw>, C<-nbc> etc (but also have double-dash options like
#C<--no-window-system> or C<--no-blinking-cursor>).
#
#=item * B<completion> => I<code>
#
#Completion routine to complete option valueE<sol>argument.
#
script/_chinese-zodiac-of view on Meta::CPAN
# summary => 'Command-line arguments',
# schema => ['array*' => {of=>'str*'}],
# req => 1,
# },
# cword => {
# summary => 'On which argument cursor is located (zero-based)',
# schema => 'int*',
# req => 1,
# },
# completion => {
# summary => 'Supply custom completion routine',
script/_chinese-zodiac-of view on Meta::CPAN
#
#=back
#
#=item * B<cword>* => I<int>
#
#On which argument cursor is located (zero-based).
#
#=item * B<extras> => I<hash>
#
#Add extra arguments to completion routine.
#
App-ZofCMS
view release on metacpan or search on metacpan
lib/App/ZofCMS/Plugin/LinksToSpecs/CSS.pm view on Meta::CPAN
=> q|http://w3.org/TR/CSS21/visuren.html#propdef-clear|,
'padding'
=> q|http://w3.org/TR/CSS21/box.html#propdef-padding|,
'cursor'
=> q|http://w3.org/TR/CSS21/ui.html#propdef-cursor|,
'float'
=> q|http://w3.org/TR/CSS21/visuren.html#propdef-float|,
'border-right-color'
App-after
view release on metacpan or search on metacpan
# v => 1.1,
# summary => 'Return line with point marked by a marker',
# description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
# description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
# position of cursor, for example (`^` marks the position of cursor):
# `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
# doing tab completion.
#
#_
# schema => 'hash*',
#single dash will be completed. For example if you have `-foo=s` in your option
#specification, `-f<tab>` can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like `-nw`, `-nbc` etc (but also have double-dash options like
#`--no-window-system` or `--no-blinking-cursor`).
#
#_
# },
# },
# result_naked => 1,
# summary => 'Command-line arguments',
# schema => ['array*' => {of=>'str*'}],
# req => 1,
# },
# cword => {
# summary => 'On which argument cursor is located (zero-based)',
# schema => 'int*',
# req => 1,
# },
# completion => {
# summary => 'Supply custom completion routine',
App-bsky
view release on metacpan or search on metacpan
lib/App/bsky.pm view on Meta::CPAN
# TODO
method cmd_likes ( $uri, @args ) {
GetOptionsFromArray( \@args, 'json!' => \my $json );
my @likes;
my $cursor = ();
do {
my $likes = $bsky->at->get( 'app.bsky.feed.getLikes', { uri => $uri, limit => 100, cursor => $cursor } );
push @likes, @{ $likes->{likes} };
$cursor = $likes->{cursor};
} while ($cursor);
if ($json) {
$self->say( JSON::Tiny::to_json \@likes );
}
else {
$self->say(
lib/App/bsky.pm view on Meta::CPAN
# TODO
method cmd_reposts ( $uri, @args ) {
GetOptionsFromArray( \@args, 'json!' => \my $json );
my @reposts;
my $cursor = ();
do {
my $reposts = $bsky->at->get( 'app.bsky.feed.getRepostedBy', { uri => $uri, limit => 100, cursor => $cursor } );
push @reposts, @{ $reposts->{repostedBy} };
$cursor = $reposts->{cursor};
} while ($cursor);
if ($json) {
$self->say( JSON::Tiny::to_json \@reposts );
}
else {
$self->say( '%s%s%s%s', color('red'), $_->{handle}, color('reset'), defined $_->{displayName} ? ' [' . $_->{displayName} . ']' : '' )
lib/App/bsky.pm view on Meta::CPAN
# TODO
method cmd_follows (@args) {
GetOptionsFromArray( \@args, 'json!' => \my $json, 'handle|H=s' => \my $handle );
my @follows;
my $cursor = ();
do {
my $follows = $bsky->at->get( 'app.bsky.graph.getFollows',
{ actor => $handle // $config->{session}{handle}, limit => 100, cursor => $cursor } );
push @follows, @{ $follows->{follows} };
$cursor = $follows->{cursor};
} while ($cursor);
if ($json) {
$self->say( JSON::Tiny::to_json \@follows );
}
else {
for my $follow (@follows) {
lib/App/bsky.pm view on Meta::CPAN
}
method cmd_followers (@args) {
GetOptionsFromArray( \@args, 'json!' => \my $json, 'handle|H=s' => \my $handle );
my @followers;
my $cursor = ();
do {
my $followers = $bsky->at->get( 'app.bsky.graph.getFollowers',
{ actor => $handle // $config->{session}{handle}, limit => 100, cursor => $cursor } );
$followers // last;
if ( defined $followers->{followers} ) {
push @followers, @{ $followers->{followers} };
$cursor = $followers->{cursor};
}
} while ($cursor);
if ($json) {
$self->say( JSON::Tiny::to_json [ map {$_} @followers ] );
}
else {
my $len1 = my $len2 = 0;
lib/App/bsky.pm view on Meta::CPAN
# TODO
method cmd_blocks (@args) {
GetOptionsFromArray( \@args, 'json!' => \my $json );
my @blocks;
my $cursor = ();
do {
my $follows = $bsky->at->get( 'app.bsky.graph.getBlocks', { limit => 100, cursor => $cursor } );
push @blocks, @{ $follows->{blocks} };
$cursor = $follows->{cursor};
} while ($cursor);
if ($json) {
$self->say( JSON::Tiny::to_json \@blocks );
}
else {
for my $follow (@blocks) {
lib/App/bsky.pm view on Meta::CPAN
my $notification_count = $bsky->at->get('app.bsky.notification.getUnreadCount');
$notification_count || $notification_count->throw;
return $self->say( $json ? '[]' : 'No unread notifications' ) unless $notification_count->{count};
}
my @notes;
my $cursor = ();
do {
my $notes = $bsky->at->get( 'app.bsky.notification.listNotifications', { limit => 100, cursor => $cursor } );
$notes || $notes->throw;
push @notes, @{ $notes->{notifications} };
$cursor = $all && $notes->{cursor} ? $notes->{cursor} : ();
} while ($cursor);
return $self->say( JSON::Tiny::to_json [ map {$_} @notes ] ) if $json;
return $self->say('No notifications.') unless @notes;
for my $note (@notes) {
$self->say(
'%s%s%s%s %s', color('red'), $note->{author}{handle},
App-cpanminus
view release on metacpan or search on metacpan
lib/App/cpanminus/fatscript.pm view on Meta::CPAN
# Iterate over the documents
my $indent = 0;
my @lines = ();
eval {
foreach my $cursor ( @$self ) {
push @lines, '---';
# An empty document
if ( ! defined $cursor ) {
# Do nothing
# A scalar document
} elsif ( ! ref $cursor ) {
$lines[-1] .= ' ' . $self->_dump_scalar( $cursor );
# A list at the root
} elsif ( ref $cursor eq 'ARRAY' ) {
unless ( @$cursor ) {
$lines[-1] .= ' []';
next;
}
push @lines, $self->_dump_array( $cursor, $indent, {} );
# A hash at the root
} elsif ( ref $cursor eq 'HASH' ) {
unless ( %$cursor ) {
$lines[-1] .= ' {}';
next;
}
push @lines, $self->_dump_hash( $cursor, $indent, {} );
} else {
die \("Cannot serialize " . ref($cursor));
}
}
};
if ( ref $@ eq 'SCALAR' ) {
$self->_error(${$@});
App-cpantimes
view release on metacpan or search on metacpan
return '' unless @$self;
# Iterate over the documents
my $indent = 0;
my @lines = ();
foreach my $cursor ( @$self ) {
push @lines, '---';
# An empty document
if ( ! defined $cursor ) {
# Do nothing
# A scalar document
} elsif ( ! ref $cursor ) {
$lines[-1] .= ' ' . $self->_write_scalar( $cursor, $indent );
# A list at the root
} elsif ( ref $cursor eq 'ARRAY' ) {
unless ( @$cursor ) {
$lines[-1] .= ' []';
next;
}
push @lines, $self->_write_array( $cursor, $indent, {} );
# A hash at the root
} elsif ( ref $cursor eq 'HASH' ) {
unless ( %$cursor ) {
$lines[-1] .= ' {}';
next;
}
push @lines, $self->_write_hash( $cursor, $indent, {} );
} else {
Carp::croak("Cannot serialize " . ref($cursor));
}
}
join '', map { "$_\n" } @lines;
}
App-devmode
view release on metacpan or search on metacpan
bin/devmode view on Meta::CPAN
#wyse-75-42 must have flow control (xo = "terminal uses xon/xoff")
#essential to have it here, as this is a slow terminal.
termcapinfo wy75-42 xo:hs@
# New termcap sequences for cursor application mode.
termcapinfo wy* CS=\E[?1h:CE=\E[?1l:vi=\E[?25l:ve=\E[?25h:VR=\E[?5h:VN=\E[?5l:cb=\E[1K:CD=\E[1J
################
#
# other terminals
App-diceware
view release on metacpan or search on metacpan
share/wordlist_de.tsv view on Meta::CPAN
16524 cs
16525 csu
16526 ct
16531 cu
16532 curium
16533 cursor
16534 cv
16535 cvjm
16536 cw
16541 cx
16542 cy
App-docsisious
view release on metacpan or search on metacpan
lib/App/docsisious/public/icons/flaticon.html view on Meta::CPAN
display: block;
width: 100px;
margin: 5px auto;
text-align: center;
font-size: 12px;
cursor: text;
}
.glyph > input.icon-input {
font-family:"Flaticon";
font-size: 16px;
margin-bottom: 10px;
App-dropboxapi
view release on metacpan or search on metacpan
script/dropbox-api view on Meta::CPAN
}
my @entries;
my $fetch;
my $count = 0;
$fetch = sub {
my $cursor = shift;
my $list;
if ($cursor) {
$list = $box->list_folder_continue($cursor) or die $box->error;
} else {
$list = $box->list_folder($remote_base, {
recursive => JSON::true,
}) or die $box->error;
}
script/dropbox-api view on Meta::CPAN
if ($verbose) {
$| = 1;
$count++;
printf("\r" . (('.') x $count));
}
$fetch->($list->{cursor});
}
};
$fetch->();
if ($verbose) {
print "\n";
script/dropbox-api view on Meta::CPAN
# finish or small file
if ($total < $limit) {
if ($session_id) {
my $params = {
cursor => {
session_id => $session_id,
offset => $offset,
},
commit => $commit_params,
};
script/dropbox-api view on Meta::CPAN
}
# append
elsif ($session_id) {
my $params = {
cursor => {
session_id => $session_id,
offset => $offset,
},
};
unless ($box->upload_session_append_v2($tmp, $params)) {
App-financeta
view release on metacpan or search on metacpan
lib/App/financeta/gui/editor.pm view on Meta::CPAN
# hiliteIDs => [$keywords, cl::Green],
tabIndent => 4,
size => \@sz,
visible => 1,
# check these
cursorWrap => 1,
persistentBlock => 1,
wantTabs => 1,
);
my $regexes = $self->compiler->get_grammar_regexes($is_dark_mode);
my @arr = ();
App-finddo
view release on metacpan or search on metacpan
script/_finddo view on Meta::CPAN
# v => 1.1,
# summary => 'Return line with point marked by a marker',
# description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
script/_finddo view on Meta::CPAN
# description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
# position of cursor, for example (`^` marks the position of cursor):
# `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
# doing tab completion.
#
#_
# schema => 'hash*',
script/_finddo view on Meta::CPAN
#single dash will be completed. For example if you have `-foo=s` in your option
#specification, `-f<tab>` can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like `-nw`, `-nbc` etc (but also have double-dash options like
#`--no-window-system` or `--no-blinking-cursor`).
#
#_
# },
# },
# result_naked => 1,
script/_finddo view on Meta::CPAN
# summary => 'Command-line arguments',
# schema => ['array*' => {of=>'str*'}],
# req => 1,
# },
# cword => {
# summary => 'On which argument cursor is located (zero-based)',
# schema => 'int*',
# req => 1,
# },
# completion => {
# summary => 'Supply custom completion routine',
App-genpw-base56
view release on metacpan or search on metacpan
script/_genpw-base56 view on Meta::CPAN
# v => 1.1,
# summary => 'Return line with point marked by a marker',
# description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
script/_genpw-base56 view on Meta::CPAN
# description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
# position of cursor, for example (`^` marks the position of cursor):
# `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
# doing tab completion.
#
#_
# schema => 'hash*',
script/_genpw-base56 view on Meta::CPAN
#single dash will be completed. For example if you have `-foo=s` in your option
#specification, `-f<tab>` can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like `-nw`, `-nbc` etc (but also have double-dash options like
#`--no-window-system` or `--no-blinking-cursor`).
#
#_
# },
# },
# result_naked => 1,
script/_genpw-base56 view on Meta::CPAN
# summary => 'Command-line arguments',
# schema => ['array*' => {of=>'str*'}],
# req => 1,
# },
# cword => {
# summary => 'On which argument cursor is located (zero-based)',
# schema => 'int*',
# req => 1,
# },
# completion => {
# summary => 'Supply custom completion routine',
App-genpw-base58
view release on metacpan or search on metacpan
script/_genpw-base58 view on Meta::CPAN
# v => 1.1,
# summary => 'Return line with point marked by a marker',
# description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
script/_genpw-base58 view on Meta::CPAN
# description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
# position of cursor, for example (`^` marks the position of cursor):
# `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
# doing tab completion.
#
#_
# schema => 'hash*',
script/_genpw-base58 view on Meta::CPAN
#single dash will be completed. For example if you have `-foo=s` in your option
#specification, `-f<tab>` can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like `-nw`, `-nbc` etc (but also have double-dash options like
#`--no-window-system` or `--no-blinking-cursor`).
#
#_
# },
# },
# result_naked => 1,
script/_genpw-base58 view on Meta::CPAN
# summary => 'Command-line arguments',
# schema => ['array*' => {of=>'str*'}],
# req => 1,
# },
# cword => {
# summary => 'On which argument cursor is located (zero-based)',
# schema => 'int*',
# req => 1,
# },
# completion => {
# summary => 'Supply custom completion routine',
App-genpw-base64
view release on metacpan or search on metacpan
script/_genpw-base64 view on Meta::CPAN
# v => 1.1,
# summary => 'Return line with point marked by a marker',
# description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
script/_genpw-base64 view on Meta::CPAN
# description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
# position of cursor, for example (`^` marks the position of cursor):
# `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
# doing tab completion.
#
#_
# schema => 'hash*',
script/_genpw-base64 view on Meta::CPAN
#single dash will be completed. For example if you have `-foo=s` in your option
#specification, `-f<tab>` can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like `-nw`, `-nbc` etc (but also have double-dash options like
#`--no-window-system` or `--no-blinking-cursor`).
#
#_
# },
# },
# result_naked => 1,
script/_genpw-base64 view on Meta::CPAN
# summary => 'Command-line arguments',
# schema => ['array*' => {of=>'str*'}],
# req => 1,
# },
# cword => {
# summary => 'On which argument cursor is located (zero-based)',
# schema => 'int*',
# req => 1,
# },
# completion => {
# summary => 'Supply custom completion routine',
App-genpw-id
view release on metacpan or search on metacpan
script/_genpw-id view on Meta::CPAN
# v => 1.1,
# summary => 'Return line with point marked by a marker',
# description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
script/_genpw-id view on Meta::CPAN
# description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
# position of cursor, for example (`^` marks the position of cursor):
# `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
# doing tab completion.
#
#_
# schema => 'hash*',
script/_genpw-id view on Meta::CPAN
# # this is a workaround. since bash breaks words using characters in
# # $COMP_WORDBREAKS, which by default is "'@><=;|&(: this presents a problem
# # we often encounter: if we want to provide with a list of strings
# # containing say ':', most often Perl modules/packages, if user types e.g.
# # "Text::AN" and we provide completion ["Text::ANSI"] then bash will change
# # the word at cursor to become "Text::Text::ANSI" since it sees the current
# # word as "AN" and not "Text::AN". the workaround is to chop /^Text::/ from
# # completion answers. btw, we actually chop /^text::/i to handle
# # case-insensitive matching, although this does not have the ability to
# # replace the current word (e.g. if we type 'text::an' then bash can only
# # replace the current word 'an' with 'ANSI).
script/_genpw-id view on Meta::CPAN
# % somecmd t<Tab>
# two three
#
#Another source is from a bash function (C<-F>). The function will receive input
#in two variables: C<COMP_WORDS> (array, command-line chopped into words) and
#C<COMP_CWORD> (integer, index to the array of words indicating the cursor
#position). It must set an array variable C<COMPREPLY> that contains the list of
#possible completion:
#
# % _foo()
# {
script/_genpw-id view on Meta::CPAN
# % foo <Tab>
# --help --verbose --version
#
#And yet another source is an external command (C<-C>) including, from a Perl
#script. The command receives two environment variables: C<COMP_LINE> (string,
#raw command-line) and C<COMP_POINT> (integer, cursor location). Program must
#split C<COMP_LINE> into words, find the word to be completed, complete that, and
#return the list of words one per-line to STDOUT. An example:
#
# % cat foo-complete
# #!/usr/bin/perl
script/_genpw-id view on Meta::CPAN
#Optional. Known options:
#
#=over
#
#=item * C<truncate_current_word> (bool). If set to 1, will truncate current word to the
#position of cursor, for example (C<^> marks the position of cursor):
#C<--vers^oo> to C<--vers> instead of C<--versoo>. This is more convenient when
#doing tab completion.
#
#=back
#
script/_genpw-id view on Meta::CPAN
# point($cmdline, $marker) -> any
#
#Return line with point marked by a marker.
#
#This is a utility function useful for testing/debugging. C<parse_cmdline()>
#expects a command-line and a cursor position (C<$line>, C<$point>). This routine
#expects C<$line> with a marker character (by default it's the caret, C<^>) and
#return (C<$line>, C<$point>) to feed to C<parse_cmdline()>.
#
#Example:
#
script/_genpw-id view on Meta::CPAN
#single dash will be completed. For example if you have `-foo=s` in your option
#specification, `-f<tab>` can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like `-nw`, `-nbc` etc (but also have double-dash options like
#`--no-window-system` or `--no-blinking-cursor`).
#
#_
# },
# },
# result_naked => 1,
script/_genpw-id view on Meta::CPAN
#single dash will be completed. For example if you have C<-foo=s> in your option
#specification, C<< -fE<lt>tabE<gt> >> can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like C<-nw>, C<-nbc> etc (but also have double-dash options like
#C<--no-window-system> or C<--no-blinking-cursor>).
#
#=item * B<completion> => I<code>
#
#Completion routine to complete option valueE<sol>argument.
#
script/_genpw-id view on Meta::CPAN
# summary => 'Command-line arguments',
# schema => ['array*' => {of=>'str*'}],
# req => 1,
# },
# cword => {
# summary => 'On which argument cursor is located (zero-based)',
# schema => 'int*',
# req => 1,
# },
# completion => {
# summary => 'Supply custom completion routine',
script/_genpw-id view on Meta::CPAN
#
#=back
#
#=item * B<cword>* => I<int>
#
#On which argument cursor is located (zero-based).
#
#=item * B<extras> => I<hash>
#
#Add extra arguments to completion routine.
#
App-genpw-ind
view release on metacpan or search on metacpan
script/_genpw-ind view on Meta::CPAN
# v => 1.1,
# summary => 'Return line with point marked by a marker',
# description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
script/_genpw-ind view on Meta::CPAN
# description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
# position of cursor, for example (`^` marks the position of cursor):
# `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
# doing tab completion.
#
#_
# schema => 'hash*',
script/_genpw-ind view on Meta::CPAN
# # this is a workaround. since bash breaks words using characters in
# # $COMP_WORDBREAKS, which by default is "'@><=;|&(: this presents a problem
# # we often encounter: if we want to provide with a list of strings
# # containing say ':', most often Perl modules/packages, if user types e.g.
# # "Text::AN" and we provide completion ["Text::ANSI"] then bash will change
# # the word at cursor to become "Text::Text::ANSI" since it sees the current
# # word as "AN" and not "Text::AN". the workaround is to chop /^Text::/ from
# # completion answers. btw, we actually chop /^text::/i to handle
# # case-insensitive matching, although this does not have the ability to
# # replace the current word (e.g. if we type 'text::an' then bash can only
# # replace the current word 'an' with 'ANSI).
script/_genpw-ind view on Meta::CPAN
# % somecmd t<Tab>
# two three
#
#Another source is from a bash function (C<-F>). The function will receive input
#in two variables: C<COMP_WORDS> (array, command-line chopped into words) and
#C<COMP_CWORD> (integer, index to the array of words indicating the cursor
#position). It must set an array variable C<COMPREPLY> that contains the list of
#possible completion:
#
# % _foo()
# {
script/_genpw-ind view on Meta::CPAN
# % foo <Tab>
# --help --verbose --version
#
#And yet another source is an external command (C<-C>) including, from a Perl
#script. The command receives two environment variables: C<COMP_LINE> (string,
#raw command-line) and C<COMP_POINT> (integer, cursor location). Program must
#split C<COMP_LINE> into words, find the word to be completed, complete that, and
#return the list of words one per-line to STDOUT. An example:
#
# % cat foo-complete
# #!/usr/bin/perl
script/_genpw-ind view on Meta::CPAN
#Optional. Known options:
#
#=over
#
#=item * C<truncate_current_word> (bool). If set to 1, will truncate current word to the
#position of cursor, for example (C<^> marks the position of cursor):
#C<--vers^oo> to C<--vers> instead of C<--versoo>. This is more convenient when
#doing tab completion.
#
#=back
#
script/_genpw-ind view on Meta::CPAN
# point($cmdline, $marker) -> any
#
#Return line with point marked by a marker.
#
#This is a utility function useful for testing/debugging. C<parse_cmdline()>
#expects a command-line and a cursor position (C<$line>, C<$point>). This routine
#expects C<$line> with a marker character (by default it's the caret, C<^>) and
#return (C<$line>, C<$point>) to feed to C<parse_cmdline()>.
#
#Example:
#
script/_genpw-ind view on Meta::CPAN
#single dash will be completed. For example if you have `-foo=s` in your option
#specification, `-f<tab>` can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like `-nw`, `-nbc` etc (but also have double-dash options like
#`--no-window-system` or `--no-blinking-cursor`).
#
#_
# },
# },
# result_naked => 1,
script/_genpw-ind view on Meta::CPAN
#single dash will be completed. For example if you have C<-foo=s> in your option
#specification, C<< -fE<lt>tabE<gt> >> can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like C<-nw>, C<-nbc> etc (but also have double-dash options like
#C<--no-window-system> or C<--no-blinking-cursor>).
#
#=item * B<completion> => I<code>
#
#Completion routine to complete option valueE<sol>argument.
#
script/_genpw-ind view on Meta::CPAN
# summary => 'Command-line arguments',
# schema => ['array*' => {of=>'str*'}],
# req => 1,
# },
# cword => {
# summary => 'On which argument cursor is located (zero-based)',
# schema => 'int*',
# req => 1,
# },
# completion => {
# summary => 'Supply custom completion routine',
script/_genpw-ind view on Meta::CPAN
#
#=back
#
#=item * B<cword>* => I<int>
#
#On which argument cursor is located (zero-based).
#
#=item * B<extras> => I<hash>
#
#Add extra arguments to completion routine.
#
App-gqmt
view release on metacpan or search on metacpan
lib/App/gqmt.pm view on Meta::CPAN
repo => $self->option('repo'),
user => $self->option('user'),
pkg_num => $self->option('rows_number'),
pkg_name => $self->option('package'),
vers_num => $self->option('rows_number'),
cursor => $arg->{inf}->{hasPreviousPage} == 1 ? sprintf(', before: "%s"', $arg->{inf}->{startCursor}) : ''
},
\$tt_out
);
$query = { query => $tt_out };
App-hr
view release on metacpan or search on metacpan
lib/App/hr.pm view on Meta::CPAN
Terminal width is determined using L<Term::Size>.
C<$pattern> is optional, can be multicharacter, but cannot be empty string. The
defautl is C<=>.
Under Windows, will shave one character at the end because the terminal cursor
will move a line down when printing at the last column.
If C<$color> is set (to a color supported by L<Term::ANSIColor>) I<and> colored
output is enabled, output will be colored. Colored output is enabled if: 1) no
C<NO_COLOR> environment variable is defined; 2) C<COLOR> is undefined or true,
App-jupiter
view release on metacpan or search on metacpan
share/default.css view on Meta::CPAN
#sidebar dd {
margin-left: 2.5em;
}
#sidebar .message {
cursor: help;
border-bottom: 1px dashed salmon;
}
#sidebar a.message:hover {
cursor: help;
background-color: #ffD0D0;
color:#000;
border: 1px dashed red !important;
text-decoration: none !important;
}
share/default.css view on Meta::CPAN
#sidebar h2 label:before {
content: "☰ ";
font-size: 1.2em;
}
#sidebar h2 label:hover {
cursor: pointer;
}
#toggle:checked ~ #toggled {
display: block;
}
#sidebar li {
share/default.css view on Meta::CPAN
/* show MEMBERS */
#sidebar h2:first-of-type {
display: block;
background-color: #ddd;
margin: 0.5em;
cursor: pointer;
}
@media (prefers-color-scheme: dark) {
#sidebar h2:first-of-type {
background-color:#222;
}
App-karr
view release on metacpan or search on metacpan
lib/App/karr/Cmd/Skill.pm view on Meta::CPAN
option agent => (
is => 'ro',
format => 's',
doc => 'Target agent (claude-code, codex, cursor)',
);
option global => (
is => 'ro',
doc => 'Install/check globally (~/) instead of project-level',
lib/App/karr/Cmd/Skill.pm view on Meta::CPAN
);
my %AGENTS = (
'claude-code' => { project => '.claude/skills', global => '.claude/skills' },
'codex' => { project => '.agents/skills', global => '.codex/skills' },
'cursor' => { project => '.cursor/skills', global => '.cursor/skills' },
);
sub execute {
my ($self, $args_ref, $chain_ref) = @_;
my $action = $args_ref->[0] // 'install';
lib/App/karr/Cmd/Skill.pm view on Meta::CPAN
version 0.102
=head1 SYNOPSIS
karr skill install
karr skill install --agent codex,cursor
karr skill check --global
karr skill update --force
karr skill show
=head1 DESCRIPTION
lib/App/karr/Cmd/Skill.pm view on Meta::CPAN
locations in the current user's home directory, which makes it useful both for
direct Perl installs and Docker-wrapped vendor usage.
=head1 SUPPORTED AGENTS
The built-in agent targets are C<claude-code>, C<codex>, and C<cursor>. When
C<--agent> is omitted, the command auto-detects available client directories and
falls back to all known agents if nothing is detected.
=head1 ACTIONS
App-metasyn
view release on metacpan or search on metacpan
script/_metasyn view on Meta::CPAN
# v => 1.1,
# summary => 'Return line with point marked by a marker',
# description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
script/_metasyn view on Meta::CPAN
# description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
# position of cursor, for example (`^` marks the position of cursor):
# `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
# doing tab completion.
#
#_
# schema => 'hash*',
script/_metasyn view on Meta::CPAN
# # this is a workaround. since bash breaks words using characters in
# # $COMP_WORDBREAKS, which by default is "'@><=;|&(: this presents a problem
# # we often encounter: if we want to provide with a list of strings
# # containing say ':', most often Perl modules/packages, if user types e.g.
# # "Text::AN" and we provide completion ["Text::ANSI"] then bash will change
# # the word at cursor to become "Text::Text::ANSI" since it sees the current
# # word as "AN" and not "Text::AN". the workaround is to chop /^Text::/ from
# # completion answers. btw, we actually chop /^text::/i to handle
# # case-insensitive matching, although this does not have the ability to
# # replace the current word (e.g. if we type 'text::an' then bash can only
# # replace the current word 'an' with 'ANSI).
script/_metasyn view on Meta::CPAN
# % somecmd t<Tab>
# two three
#
#Another source is from a bash function (C<-F>). The function will receive input
#in two variables: C<COMP_WORDS> (array, command-line chopped into words) and
#C<COMP_CWORD> (integer, index to the array of words indicating the cursor
#position). It must set an array variable C<COMPREPLY> that contains the list of
#possible completion:
#
# % _foo()
# {
script/_metasyn view on Meta::CPAN
# % foo <Tab>
# --help --verbose --version
#
#And yet another source is an external command (C<-C>) including, from a Perl
#script. The command receives two environment variables: C<COMP_LINE> (string,
#raw command-line) and C<COMP_POINT> (integer, cursor location). Program must
#split C<COMP_LINE> into words, find the word to be completed, complete that, and
#return the list of words one per-line to STDOUT. An example:
#
# % cat foo-complete
# #!/usr/bin/perl
script/_metasyn view on Meta::CPAN
#Optional. Known options:
#
#=over
#
#=item * C<truncate_current_word> (bool). If set to 1, will truncate current word to the
#position of cursor, for example (C<^> marks the position of cursor):
#C<--vers^oo> to C<--vers> instead of C<--versoo>. This is more convenient when
#doing tab completion.
#
#=back
#
script/_metasyn view on Meta::CPAN
# point($cmdline, $marker) -> any
#
#Return line with point marked by a marker.
#
#This is a utility function useful for testing/debugging. C<parse_cmdline()>
#expects a command-line and a cursor position (C<$line>, C<$point>). This routine
#expects C<$line> with a marker character (by default it's the caret, C<^>) and
#return (C<$line>, C<$point>) to feed to C<parse_cmdline()>.
#
#Example:
#
script/_metasyn view on Meta::CPAN
#single dash will be completed. For example if you have `-foo=s` in your option
#specification, `-f<tab>` can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like `-nw`, `-nbc` etc (but also have double-dash options like
#`--no-window-system` or `--no-blinking-cursor`).
#
#_
# },
# },
# result_naked => 1,
script/_metasyn view on Meta::CPAN
#single dash will be completed. For example if you have C<-foo=s> in your option
#specification, C<< -fE<lt>tabE<gt> >> can complete it.
#
#This can be used to complete old-style programs, e.g. emacs which has options
#like C<-nw>, C<-nbc> etc (but also have double-dash options like
#C<--no-window-system> or C<--no-blinking-cursor>).
#
#=item * B<completion> => I<code>
#
#Completion routine to complete option valueE<sol>argument.
#
script/_metasyn view on Meta::CPAN
# summary => 'Command-line arguments',
# schema => ['array*' => {of=>'str*'}],
# req => 1,
# },
# cword => {
# summary => 'On which argument cursor is located (zero-based)',
# schema => 'int*',
# req => 1,
# },
# completion => {
# summary => 'Supply custom completion routine',
script/_metasyn view on Meta::CPAN
#
#=back
#
#=item * B<cword>* => I<int>
#
#On which argument cursor is located (zero-based).
#
#=item * B<extras> => I<hash>
#
#Add extra arguments to completion routine.
#
App-mimi
view release on metacpan or search on metacpan
mimi.fatpack view on Meta::CPAN
}
};$method_code =~ s/\~(\w+)\~/$expand{$1}/eg;local$SIG{__DIE__}='DEFAULT';my$err=do {local $@;eval$method_code.2;$@};die$err if$err;goto &$AUTOLOAD}sub DESTROY {my$dbh=shift;local $@ if $@;$dbh->disconnect if$dbh->SUPER::FETCH('Active')}sub con...
DBD_PROXY
$fatpacked{"DBD/Sponge.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'DBD_SPONGE';
use strict;{package DBD::Sponge;require DBI;require Carp;our@EXPORT=qw();our$VERSION="0.03";our$drh=undef;my$methods_already_installed;sub driver{return$drh if$drh;DBD::Sponge::db->install_method("sponge_test_installed_method")unless$methods_alread...
DBD_SPONGE
$fatpacked{"DBI.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'DBI';
package DBI;require 5.008_001;BEGIN {our$XS_VERSION=our$VERSION="0.03";$VERSION=eval$VERSION}use Carp();use DynaLoader ();use Exporter ();BEGIN {@ISA=qw(Exporter DynaLoader);@EXPORT=();@EXPORT_OK=qw(%DBI %DBI_methods hash);%EXPORT_TAGS=(sql_types=>...
DBI::_firesafe; # just in case
require $driver_class; # load the driver
};if ($@){my$err=$@;my$advice="";if ($err =~ /Can't find loadable object/){$advice="Perhaps DBD::$driver was statically linked into a new perl binary." ."\nIn which case you need to use that new perl binary." ."\nOr perhaps only the .pm file wa...
DBI
App-mojopaste
view release on metacpan or search on metacpan
script/mojopaste view on Meta::CPAN
line-height: calc(var(--nav-height) - var(--padding) * 2);
margin-left: calc(var(--gutter) / 2);
padding: var(--padding) calc(var(--gutter) / 2);
float: left;
display: block;
cursor: pointer;
}
.brand {
display: block !important;
}
App-optex-scroll
view release on metacpan or search on metacpan
lib/App/optex/scroll.pm view on Meta::CPAN
}
my $region = $opt{line};
flush "\n" x $region;
flush csi_code(CPL => $region); # CPL: Cursor Previous Line
my($l, $c) = cursor_position() or return;
set_region($l, $l + $region);
if (my $time = $opt{interval}) {
interval(time => $time);
}
}
sub cursor_position {
my $answer = ask(csi_code(DSR => 6), qr/R\z/); # DSR: Device Status Report
csi_report(CPR => 2, $answer); # CPR: Cursor Position Report
}
sub uncntrl {
lib/App/optex/scroll.pm view on Meta::CPAN
B<optex>'s B<scroll> module prevents a command that produces output
longer than terminal hight from causing the executed command line to
scroll out from the screen.
It sets the scroll region for the output of the command it executes.
The output of the command scrolls by default 10 lines from the cursor
position where it was executed.
=head1 OPTIONS
=over 7
App-perlminlint
view release on metacpan or search on metacpan
perlminlint is distributed with [perl-minlint-mode](./elisp/README.md).
In this mode, perlminlint is called automatically whenever you save
your perl script.
Also you can run perlminlint manually by hitting `<F5>`.
If your script has an error, cursor will jump to the position.
perl-minlint-mode supports
[tramp mode](http://www.emacswiki.org/emacs/TrampMode), so
you can safely lint remote files too
if you install perlminlint on your remote hosts.
( run in 0.995 second using v1.01-cache-2.11-cpan-39bf76dae61 )