Result:
found more than 394 distributions - search limited to the first 2001 files matching your query
( run in 2.050 )
App-CrossPericmd
view release on metacpan or search on metacpan
lib/App/CrossPericmd.pm view on Meta::CPAN
summary => 'Output the cross product of two or more sets',
description => <<'_',
This is more or less the same as the <prog:cross> CLI on CPAN (from
<pm:Set::CrossProduct>) except that this CLI is written using the
<pm:Perinci::CmdLine> framework. It returns table data which might be more
easily consumed by other tools.
_
args => {
aoaos => {
lib/App/CrossPericmd.pm view on Meta::CPAN
=back
This is more or less the same as the L<cross> CLI on CPAN (from
L<Set::CrossProduct>) except that this CLI is written using the
L<Perinci::CmdLine> framework. It returns table data which might be more
easily consumed by other tools.
This function is not exported.
Arguments ('*' denotes required arguments):
App-DBBrowser
view release on metacpan or search on metacpan
lib/App/DBBrowser/Table/Extensions/WindowFunctions.pm view on Meta::CPAN
}
if ( $placeholder eq 'order_by_stmt' ) {
push @parts, $win_stmt;
$win_stmt = '';
}
if ( length $win_data->{'frame_mode'} ) {
$win_stmt .= $win_data->{'frame_mode'} . " ";
if ( length $win_data->{'frame_start'} || $placeholder eq 'frame_start' ) {
if ( length $win_data->{'frame_end'} || $placeholder eq 'frame_end' ) {
$win_stmt .= "BETWEEN ";
}
if ( length $win_data->{'frame_start'} ) {
$win_stmt .= $win_data->{'frame_start'} . " ";
}
if ( $placeholder eq 'frame_start' ) {
push @parts, $win_stmt;
$win_stmt = '';
}
}
if ( length $win_data->{'frame_end'} || $placeholder eq 'frame_end' ) {
if ( length $win_data->{'frame_start'} || $placeholder eq 'frame_start' ) {
$win_stmt .= "AND ";
}
if ( length $win_data->{'frame_end'} ) {
$win_stmt .= $win_data->{'frame_end'} . " ";
}
if ( $placeholder eq 'frame_end' ) {
push @parts, $win_stmt;
$win_stmt = '';
}
}
if ( length $win_data->{'frame_exclusion'} ) {
$win_stmt .= $win_data->{'frame_exclusion'};
}
if ( $placeholder eq 'frame_exclusion' ) {
push @parts, $win_stmt;
$win_stmt = '';
}
}
if ( $placeholder eq 'frame_mode' ) {
push @parts, $win_stmt;
$win_stmt = '';
}
if ( ! $placeholder ) {
push @parts, $win_stmt;
lib/App/DBBrowser/Table/Extensions/WindowFunctions.pm view on Meta::CPAN
}
}
my $old_idx = 0;
WINDOW_DEFINITION: while( 1 ) {
my ( $partition_by, $order_by, $frame_clause ) = ( '- Partition by', '- Order by', '- Frame clause' );
my @pre = ( undef, $sf->{i}{confirm} );
my $menu = [ @pre, $partition_by, $order_by, $frame_clause ];
$r_data->[-1] = [ 'win', $sf->__get_win_func_stmt( $win_data ) ];
my $info = $info_sql . $ext->nested_func_info( $r_data );
# Choose
my $idx_wd = $tc->choose(
$menu,
{ %{$sf->{i}{lyt_v}}, info => $info, prompt => '', index => 1, default => $old_idx,
undef => $sf->{i}{back} }
);
if ( ! defined $idx_wd || ! defined $menu->[$idx_wd] ) {
if ( $win_data->{'partition_by_stmt'} || $win_data->{'order_by_stmt'} || $win_data->{'frame_mode'} ) {
$win_data = { func => $win_data->{'func'}, args_str => $win_data->{'args_str'} };
next WINDOW_DEFINITION;
}
if ( $func =~ /^(?:$rx_func_count_all|$rx_func_no_col)\z/ ) {
next WINDOW_FUNCTION;
lib/App/DBBrowser/Table/Extensions/WindowFunctions.pm view on Meta::CPAN
$sf->__add_partition_by( $sql, $clause, $cols, $r_data, $win_data );
}
elsif ( $wd eq $order_by ) {
$sf->__add_order_by( $sql, $clause, $cols, $r_data, $win_data );
}
elsif ( $wd eq $frame_clause ) {
$sf->__add_frame_clause( $sql, $clause, $r_data, $win_data );
}
}
}
}
}
lib/App/DBBrowser/Table/Extensions/WindowFunctions.pm view on Meta::CPAN
}
}
}
sub __add_frame_clause {
my ( $sf, $sql, $clause, $r_data, $win_data ) = @_;
my $ax = App::DBBrowser::Auxil->new( $sf->{i}, $sf->{o}, $sf->{d} );
my $ext = App::DBBrowser::Table::Extensions->new( $sf->{i}, $sf->{o}, $sf->{d} );
my $tc = Term::Choose->new( $sf->{i}{tc_default} );
my $dbms = $sf->{i}{dbms};
my @frame_clause_modes = ( 'ROWS', 'RANGE' );
if ( $dbms =~ /^(?:SQLite|Pg|DuckDB|Oracle)\z/ ) {
push @frame_clause_modes, 'GROUPS';
}
if ( ! length $win_data->{'frame_mode'} ) {
$r_data->[-1] = [ 'win', $sf->__get_win_func_stmt( $win_data, 'frame_mode' ) ];
}
my $info_sql = $ax->get_sql_info( $sql );
my $old_idx_fc = 0;
FRAME_CLAUSE: while ( 1 ) {
my $info = $info_sql . $ext->nested_func_info( $r_data );
my @pre = ( undef );
my $menu = [ @pre, map { '- ' . $_ } @frame_clause_modes ];
# Choose
my $idx_fc = $tc->choose(
$menu,
{ %{$sf->{i}{lyt_v}}, info => $info, index => 1, default => $old_idx_fc, prompt => 'Frame clause:', undef => ' <=' }
);
lib/App/DBBrowser/Table/Extensions/WindowFunctions.pm view on Meta::CPAN
$old_idx_fc = 0;
next FRAME_CLAUSE;
}
$old_idx_fc = $idx_fc;
}
my $frame_mode = $frame_clause_modes[$idx_fc-@pre];
$win_data->{'frame_mode'} = $frame_mode;
my $old_idx_fe = 0;
FRAME_END_AND_EXCLUSION: while ( 1 ) {
my $confirm = $sf->{i}{confirm};
my $back = $sf->{i}{back};
my @pre = ( undef, $confirm );
my ( $frame_start, $frame_end, $frame_exclusion ) = ( '- Add Frame start', '- Add Frame end', '- Add Frame exclusion' );
my $menu = [ @pre, $frame_start, $frame_end ];
if ( $dbms =~ /^(?:SQLite|Pg|DuckDB|Oracle)\z/ ) {
push @$menu, $frame_exclusion;
}
$r_data->[-1] = [ 'win', $sf->__get_win_func_stmt( $win_data, 'frame_mode' ) ];
my $info = $info_sql . $ext->nested_func_info( $r_data );
# Choose
my $idx_fe = $tc->choose(
$menu,
{ %{$sf->{i}{lyt_v}}, info => $info, index => 1, default => $old_idx_fe, prompt => 'Frame clause:', undef => $back }
);
$ax->print_sql_info( $info );
if ( ! defined $idx_fe || ! defined $menu->[$idx_fe] ) {
if ( $win_data->{'frame_start'} || $win_data->{'frame_end'} || $win_data->{'frame_exclusion'} ) {
delete @{$win_data}{qw(frame_start frame_end frame_exclusion)};
next FRAME_END_AND_EXCLUSION;
}
delete $win_data->{'frame_mode'};
next FRAME_CLAUSE;
}
if ( $sf->{o}{G}{menu_memory} ) {
if ( $old_idx_fe == $idx_fe && ! $ENV{TC_RESET_AUTO_UP} ) {
$old_idx_fe = 0;
lib/App/DBBrowser/Table/Extensions/WindowFunctions.pm view on Meta::CPAN
}
my $choice = $menu->[$idx_fe];
if ( $choice eq $confirm ) {
return 1;
}
if ( $choice eq $frame_start ) {
$sf->__add_frame_start_or_end( $sql, $clause, $r_data, $win_data, 'frame_start' );
}
elsif ( $choice eq $frame_end ) {
$sf->__add_frame_start_or_end( $sql, $clause, $r_data, $win_data, 'frame_end' );
}
else {
$sf->__add_frame_exclusion( $sql, $r_data, $win_data );
}
}
}
}
sub __add_frame_start_or_end {
my ( $sf, $sql, $clause, $r_data, $win_data, $pos ) = @_;
my $ax = App::DBBrowser::Auxil->new( $sf->{i}, $sf->{o}, $sf->{d} );
my $ext = App::DBBrowser::Table::Extensions->new( $sf->{i}, $sf->{o}, $sf->{d} );
my $tc = Term::Choose->new( $sf->{i}{tc_default} );
my $dbms = $sf->{i}{dbms};
my ( @frame_point_types, $prompt );
if ( $pos eq 'frame_start' ) {
if ( $win_data->{'frame_mode'} eq 'RANGE' && $dbms eq 'MSSQL' ) {
@frame_point_types = ( 'UNBOUNDED PRECEDING', 'CURRENT ROW' );
}
else {
@frame_point_types = ( 'UNBOUNDED PRECEDING', 'n PRECEDING', 'CURRENT ROW', 'n FOLLOWING' );
}
$prompt = 'Frame start:';
}
elsif ( $pos eq 'frame_end' ) {
if ( $win_data->{'frame_mode'} eq 'RANGE' && $dbms eq 'MSSQL' ) {
@frame_point_types = ( 'CURRENT ROW', 'UNBOUNDED FOLLOWING' );
}
else {
@frame_point_types = ( 'n PRECEDING', 'CURRENT ROW', 'n FOLLOWING', 'UNBOUNDED FOLLOWING' );
}
$prompt = 'Frame end:';
}
my $info_sql = $ax->get_sql_info( $sql );
lib/App/DBBrowser/Table/Extensions/WindowFunctions.pm view on Meta::CPAN
$r_data->[-1] = [ 'win', $sf->__get_win_func_stmt( $win_data ) ];
}
my $info = $info_sql . $ext->nested_func_info( $r_data );
my $confirm = $sf->{i}{ok};
my @pre = ( undef, $confirm );
my $menu = [ @pre, map( '- ' . $_, @frame_point_types ) ];
# Choose
my $point = $tc->choose(
$menu,
{ %{$sf->{i}{lyt_v}}, info => $info, prompt => $prompt, undef => '<=' }
);
lib/App/DBBrowser/Table/Extensions/WindowFunctions.pm view on Meta::CPAN
}
}
}
sub __add_frame_exclusion {
my ( $sf, $sql, $r_data, $win_data ) = @_;
my $ax = App::DBBrowser::Auxil->new( $sf->{i}, $sf->{o}, $sf->{d} );
my $ext = App::DBBrowser::Table::Extensions->new( $sf->{i}, $sf->{o}, $sf->{d} );
my $tc = Term::Choose->new( $sf->{i}{tc_default} );
my @exclusion_types = ( 'EXCLUDE CURRENT ROW', 'EXCLUDE GROUP', 'EXCLUDE TIES', 'EXCLUDE NO OTHERS' );
my $info_sql = $ax->get_sql_info( $sql );
FRAME_EXCLUSION: while ( 1 ) {
if ( ! length $win_data->{'frame_exclusion'} ) {
$r_data->[-1] = [ 'win', $sf->__get_win_func_stmt( $win_data, 'frame_exclusion' ) ];
}
else {
$r_data->[-1] = [ 'win', $sf->__get_win_func_stmt( $win_data ) ];
}
my $info = $info_sql . $ext->nested_func_info( $r_data );
my $confirm = $sf->{i}{ok};
my @pre = ( undef, $confirm );
my $menu = [ @pre, map( '- ' . $_, @exclusion_types ) ];
# Choose
my $frame_exclusion = $tc->choose(
$menu,
{ %{$sf->{i}{lyt_v}}, info => $info, prompt => 'Frame exclusion:', undef => '<=' }
);
$ax->print_sql_info( $info );
if ( ! defined $frame_exclusion ) {
delete $win_data->{'frame_exclusion'};
return;
}
elsif ( $frame_exclusion eq $confirm ) {
return 1;
}
else {
$frame_exclusion =~ s/^-\s//;
$win_data->{'frame_exclusion'} = $frame_exclusion;
}
}
}
App-DBCritic
view release on metacpan or search on metacpan
0.011 2011-08-06 13:49:04 America/New_York
- require more recent version of DBIx::Class
- fix synopsis (reported by frew++)
- fill in DBICSC::Policy::NullableTextColumn pod with data types checked
0.010 2011-07-29 16:44:18 America/New_York
- converted from Moose to Moo object framework (requested by mst++)
0.005 2011-07-29 13:04:52 America/New_York
- dsn is now a required attribute, defaults to schema object's storage.
- cache stringification of Violation objects
0.004 2011-07-28 18:29:40 America/New_York
- initial release
App-Dapper
view release on metacpan or search on metacpan
0.21 2025-01-22
Added CGI to list of module dependencies.
0.20 2025-01-21
Removed dependency on YAML::Tiny from test framework
0.19 2025-01-20
Changed to Net::HTTPServer for local webserver use. This is a much
better forking webserver to use than HTML::Brick and better supported.
App-Devel-MAT-Explorer-GTK
view release on metacpan or search on metacpan
lib/App/Devel/MAT/Explorer/GTK/Widgets.pm view on Meta::CPAN
use List::Util qw( pairs );
use Exporter 'import';
our @EXPORT_OK = qw(
framed
label
textarea
vscrollable
);
our %EXPORT_TAGS = (
all => [ @EXPORT_OK ],
);
sub framed
{
my ( $widget ) = @_;
my $frame = Gtk2::Frame->new;
$frame->set_shadow_type( "in" );
$frame->add( $widget );
return $frame;
}
sub label
{
my ( $text ) = @_;
App-Dex
view release on metacpan or search on metacpan
scripts/dex view on Meta::CPAN
These projects are a big help for any developer. So I got the idea
to write my own parser and started on New Year's Day 2017.
Without the test suite and the editor I would have never started this.
I also started another YAML Test project which allows one to get a quick
overview of which frameworks support which YAML features:
=over 4
=item L<"YAML TEST MATRIX">
scripts/dex view on Meta::CPAN
This is a tool to play around with several YAML parsers and loaders in vim.
L<https://github.com/yaml/yaml-editor>
The project contains the code to build the frameworks (16 as of this
writing) and put it into one big Docker image.
It also contains the yaml-editor itself, which will start a vim in the docker
container. It uses a lot of funky vimscript that makes playing with it easy
and useful. You can choose which frameworks you want to test and see the
output in a grid of vim windows.
Especially when writing a parser it is extremely helpful to have all
the test cases and be able to play around with your own examples to see
how they are handled.
=head2 YAML TEST MATRIX
I was curious to see how the different frameworks handle the test cases,
so, using the test suite and the docker image, I wrote some code that runs
the tests, manipulates the output to compare it with the expected output,
and created a matrix view.
L<https://github.com/perlpunk/yaml-test-matrix>
App-DocKnot
view release on metacpan or search on metacpan
t/data/generate/c-tap-harness/docknot.yaml view on Meta::CPAN
and can then use the functions defined in the library.
* Optionally copy `docs/writing-tests` into your package somewhere,
such as `tests/README`, as instructions to contributors on how to
write tests for this framework.
If you have configuration files that the user must create to enable
some of the tests, conventionally they go into `tests/config`.
If you have data files that your test cases use, conventionally they
App-Dochazka-WWW
view release on metacpan or search on metacpan
share/js/dochazka-www/lib.js view on Meta::CPAN
}
},
//
// function returns string that will be displayed at the very
// bottom of the screen (directly under the frame)
//
fillNoticesLine: function () {
var r = '';
r += 'Copyright \u00A9 SUSE LLC, 2014-2016. All rights reserved. ';
r += 'Report bugs at ';
App-DrivePlayer
view release on metacpan or search on metacpan
lib/App/DrivePlayer/GUI.pm view on Meta::CPAN
return $hbox;
}
sub _build_controls {
my ($self) = @_;
my $frame = Gtk3::Frame->new();
my $vbox = Gtk3::Box->new('vertical', 2);
$vbox->set_border_width(4);
$frame->add($vbox);
# Now-playing label
$self->now_playing_label(Gtk3::Label->new('Not playing'));
$self->now_playing_label->set_ellipsize('end');
$self->now_playing_label->set_xalign(0.0);
lib/App/DrivePlayer/GUI.pm view on Meta::CPAN
$self->vol_scale->signal_connect('value-changed' => sub {
$self->player->set_volume($self->vol_scale->get_value()) if $self->player;
});
$btn_hbox->pack_start($self->vol_scale, FALSE, FALSE, 0);
return $frame;
}
sub _icon_button {
my ($self, $icon_name, $cb) = @_;
my $btn = Gtk3::Button->new();
lib/App/DrivePlayer/GUI.pm view on Meta::CPAN
my $vbox = $dlg->get_content_area();
$vbox->set_spacing(0);
# ---- Google API credentials ----
my $auth_frame = Gtk3::Frame->new('Google API Credentials');
$auth_frame->set_border_width(8);
my $grid = Gtk3::Grid->new();
$grid->set_row_spacing(8);
$grid->set_column_spacing(8);
$grid->set_border_width(8);
$auth_frame->add($grid);
$vbox->pack_start($auth_frame, FALSE, FALSE, 0);
my $row = 0;
my %entries;
for my $field (
['client_id', 'OAuth Client ID:',
lib/App/DrivePlayer/GUI.pm view on Meta::CPAN
$auth_note->set_line_wrap(TRUE);
$auth_note->set_max_width_chars(60);
$grid->attach($auth_note, 1, $row, 1, 1);
# ---- Google Sheet sync ----
my $sheet_frame = Gtk3::Frame->new('Google Sheet Sync');
$sheet_frame->set_border_width(8);
my $sheet_grid = Gtk3::Grid->new();
$sheet_grid->set_row_spacing(8);
$sheet_grid->set_column_spacing(8);
$sheet_grid->set_border_width(8);
$sheet_frame->add($sheet_grid);
$vbox->pack_start($sheet_frame, FALSE, FALSE, 0);
my $sid_lbl = Gtk3::Label->new('Spreadsheet ID:');
$sid_lbl->set_xalign(1.0);
$sheet_grid->attach($sid_lbl, 0, 0, 1, 1);
lib/App/DrivePlayer/GUI.pm view on Meta::CPAN
$sheet_note->set_line_wrap(TRUE);
$sheet_note->set_max_width_chars(60);
$sheet_grid->attach($sheet_note, 1, 1, 1, 1);
# ---- Acoustic fingerprinting ----
my $fp_frame = Gtk3::Frame->new('Acoustic Fingerprinting (AcoustID)');
$fp_frame->set_border_width(8);
my $fp_grid = Gtk3::Grid->new();
$fp_grid->set_row_spacing(8);
$fp_grid->set_column_spacing(8);
$fp_grid->set_border_width(8);
$fp_frame->add($fp_grid);
$vbox->pack_start($fp_frame, FALSE, FALSE, 0);
# fpcalc status row
my $fp_lbl = Gtk3::Label->new('fpcalc:');
$fp_lbl->set_xalign(1.0);
$fp_grid->attach($fp_lbl, 0, 0, 1, 1);
App-Du-Analyze
view release on metacpan or search on metacpan
t/data/fc-solve-git-du-output.txt view on Meta::CPAN
49780 ./.git/objects
40 ./.git/hooks
52012 ./.git
8 ./fc-solve/benchmarks/presets-for-consideration
28 ./fc-solve/benchmarks/dumps-2.28.x/DUMPS-icc-dash-fast
36 ./fc-solve/benchmarks/dumps-2.28.x/DUMPS-icc-fomit-frame-march-p4
52 ./fc-solve/benchmarks/dumps-2.28.x/DUMPS-icc
32 ./fc-solve/benchmarks/dumps-2.28.x/DUMPS-tendra
52 ./fc-solve/benchmarks/dumps-2.28.x/DUMPS-icc-fomit-frame-march-p4-take2
276 ./fc-solve/benchmarks/dumps-2.28.x
392 ./fc-solve/benchmarks
8 ./fc-solve/site/wml/Tests
8 ./fc-solve/site/wml/lib/std
24 ./fc-solve/site/wml/lib/sass
App-DubiousHTTP
view release on metacpan or search on metacpan
lib/App/DubiousHTTP/Tests.pm view on Meta::CPAN
<ul>
<li><a href=#xhr_eicar>Firewall evasion test - Bulk test with virus payload using XMLHttpRequest</a></li>
<li><a href=#xhr_novirus>Bulk test with innocent payload using XMLHttpRequest</a></li>
<li><a href=#js>Bulk test with innocent payload using script tag</a></li>
<li><a href=#img>Bulk test with innocent payload using img tag</a></li>
<li><a href=#iframe>Bulk test with innocent payload using iframe tag</a></li>
<li><a href=#other>Various non-bulk tests</a></li>
</ul>
<hr>
lib/App/DubiousHTTP/Tests.pm view on Meta::CPAN
uncommon responses can be used to load images.
</p>
<p id=test_js class=runtest><a href="/autoimg/all/ok.png">Run Test with
innocent image payload</a></p>
<a name=iframe>
<h2>Bulk test with innocent Iframe</h2>
</a>
<p>
This bulk test will use "iframe" tags to download an innocent HTML to check which
uncommon responses can be used to load iframes. <b>Warning!</b>: IE and Edge seem
to have serious problems with some test cases here and will render the page
unresponsive.
</p>
<p id=test_iframe class=runtest><a href="/autohtml/all/parent_set_success.html">Run Test with
innocent iframe payload</a></p>
<a name=other>
<h2>Non-Bulk tests</h2>
</a>
<p>
The following tests analyze the behavior of browsers in specific cases, like
loading an image, loading a script and loading HTML into an iframe. They offer a
download for the EICAR test virus. The subtests in these tests all follow the
same style: If the browser behaves like expected (i.e. fails or succeeds) the
relevant element (IMAGE, SCRIPT or HTML) will turn green, if it behaves
differently it will turn red. Yellow is similar successful as green but marks an
uncommon behavior. If this uncommon behavior is not implemented (i.e. load of
image or script failed) the element will be grey.
When trying to load HTML into an iframe it can happen that the iframe stays
empty or contains some error message or garbage instead of "HTML". In this case
it failed to load the content.
</p>
<p>
Which behavior is expected can be seen from the header preceding
lib/App/DubiousHTTP/Tests.pm view on Meta::CPAN
});
}
sub auto_html {
my ($self,$cat) = @_;
_auto_imgjshtml($cat, 'Browser behavior test with iframe including HTML', 'parent_set_success.html', sub {
my ($url,$id) = @_;
return "<iframe id='$id' src='$url' onload='set_load(\"$id\",\"html\");' onerror='set_fail(\"$id\",\"html\");' onreadystatechange='set_load(\"$id\",\"html\");'></iframe>";
});
}
sub _auto_imgjshtml {
my ($cat,$title,$page,$mkhtml) = @_;
App-Egaz
view release on metacpan or search on metacpan
share/2_mash.tt2.sh view on Meta::CPAN
clusters <- hclust(dist_mat, method = "ward.D2")
tree <- as.phylo(clusters)
write.tree(phy=tree, file="tree.nwk")
group <- cutree(clusters, h=0.4) # k=5
groups <- as.data.frame(group)
groups$ids <- rownames(groups)
rownames(groups) <- NULL
groups <- groups[order(groups$group), ]
write_tsv(groups, "groups.tsv")
'
App-Elog
view release on metacpan or search on metacpan
lib/App/Alog.pm view on Meta::CPAN
The -p option will show the path the selected access log file.
The -f option will filter based on a given regex for the -i, -s, or -g option.
The -s option will show statistics about the access log file such
as how many requests there were, their time frame, and most active
URIs.
The -i option will show the data fields of the access log entry on
their own line, so you don't have to scroll right to see the part
you are interested in.
App-Env-Login
view release on metacpan or search on metacpan
CONTRIBUTING view on Meta::CPAN
Not Getting Any Response?
=========================
If you don't receive a response in a reasonable timeframe, please send
an email to djerius@cpan.org. It's quite possible that your original
communication was somehow lost.
App-EventStreamr
view release on metacpan or search on metacpan
share/status/app/css/bootstrap.css view on Meta::CPAN
.btn-mini .label,
.btn-mini .badge {
top: 0;
}
@-webkit-keyframes progress-bar-stripes {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
}
}
@-moz-keyframes progress-bar-stripes {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
}
}
@-ms-keyframes progress-bar-stripes {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
}
}
@-o-keyframes progress-bar-stripes {
from {
background-position: 0 0;
}
to {
background-position: 40px 0;
}
}
@keyframes progress-bar-stripes {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
App-FTNDB
view release on metacpan or search on metacpan
lib/App/FTNDB/ToDo.pod view on Meta::CPAN
Once ftnyear and yearday information for each file can be made available,
the files can be sorted by that.
Add a test nodelist for use with this?
Use a template framework of some sort instead of the builtin 'format'
operations for the reporting functionality, but perhaps keeping it as
a default? Add the type field to the List command output? Redo the
header (extra line)?
App-FargateStack
view release on metacpan or search on metacpan
lib/App/FargateStack/Checker.pm view on Meta::CPAN
sub check_passrole {
########################################################################
my ($opt) = @_;
my $role_names = $opt->get_role_names;
# role_names: arrayref of the exact role names your framework will create,
# e.g., [ 'FargateStack/my-svc/TaskExecutionRole', 'FargateStack/my-svc/TaskRole',
# 'FargateStack/my-svc/EventsInvokeRole' ]
my $sts = new_client( 'App::STS', $opt );
my $iam = new_client( 'App::IAM', $opt );
App-FfmpegUtils
view release on metacpan or search on metacpan
lib/App/FfmpegUtils.pm view on Meta::CPAN
default => 'veryslow',
cmdline_aliases => {
(map {($_ => {is_flag=>1, summary=>"Shortcut for --preset=$_", code=>do { my $p = $_; sub { $_[0]{preset} = $p }}})} @presets),
},
},
frame_rate => {
summary => 'Set frame rate, in fps',
schema => 'ufloat*',
cmdline_aliases => {r=>{}},
},
audio_sample_rate => {
summary => 'Set audio sample rate, in Hz',
lib/App/FfmpegUtils.pm view on Meta::CPAN
push @ffmpeg_args, (
"-c:v", "libx264",
"-crf", $crf,
"-preset", ($args{preset} // 'veryslow'),
(defined $args{frame_rate} ? ("-r", $args{frame_rate}) : ()),
"-c:a", ($audio_is_copy ? "copy" : "aac"),
(defined $args{audio_sample_rate} ? ("-ar", $args{audio_sample_rate}) : ()),
$output_file,
);
lib/App/FfmpegUtils.pm view on Meta::CPAN
=item * B<files>* => I<array[filename]>
(No description)
=item * B<frame_rate> => I<ufloat>
Set frame rate, in fps.
=item * B<overwrite> => I<bool>
(No description)
App-ForExample
view release on metacpan or search on metacpan
lib/App/ForExample.pm view on Meta::CPAN
no Getopt::Chain::Declare;
=head1 SEE ALSO
L<http://dev.catalystframework.org/wiki/deployment>
L<Catalyst::Engine::Apache>
L<Catalyst::Engine::FastCGI>
App-Fotagger
view release on metacpan or search on metacpan
lib/App/Fotagger/Display/SDL.pm view on Meta::CPAN
}
sub draw_image {
my $self = shift;
my $image = $self->app->current_image;
my $frame = SDL::Surface->new( -name => $image->file );
my $factor = $self->width/$image->width;
SDL::Tool::Graphic->zoom($frame,$factor,$factor);
$frame->blit( undef, $self->window, undef );
my $blank = new SDL::Rect(-width=>500, -height=>20, -y=>730, -x=>0);
$self->window->fill($blank,$self->black);
$self->window->update($blank);
$self->font->print($self->window, 5, $self->height-15, sprintf("File: %s (%s)",$image->file,$image->create_date));
App-Framework-Lite
view release on metacpan or search on metacpan
lib/App/Framework/Lite.pm view on Meta::CPAN
package App::Framework::Lite ;
=head1 NAME
App::Framework::Lite - A lightweight framework for creating applications
=head1 SYNOPSIS
use App::Framework::Lite ;
lib/App/Framework/Lite.pm view on Meta::CPAN
}
=head1 DESCRIPTION
App::Framework::Lite is a framework for quickly developing application scripts, where the majority of the mundane script setup,
documentation jobs are performed by the framework (under direction from simple text definitions stored in the script). This leaves
the developer to concentrate on the main job of implementing the application.
The module also provides the facility of embedding itself into a copy of the original script, creating a self-contained stand-alone
script (for further details see L</EMBEDDING>).
lib/App/Framework/Lite.pm view on Meta::CPAN
To jump straight in to developing applications, please see L<App::Framework::Lite::GetStarted>.
=head2 Capabilities
The application framework provides the following capabilities:
=over 2
=item Options definition
lib/App/Framework/Lite.pm view on Meta::CPAN
or environment variables.
=item Application directories
The framework automatically adds the location of the script (following any links) to the Perl search path. This means that perl modules
can be created in subdirectories under the application's script making the application self-contained.
The directories used for loading personalities/extensions/features also include the script install directory, meaning that new personalities/extensions/features
can also be provided with a script.
lib/App/Framework/Lite.pm view on Meta::CPAN
There are two ways of creating an application object and running it. The normal way is:
# Create application and run it
App::Framework::Lite->new()->go() ;
As an alternative, the framework creates a subroutine in the calling namespace called B<go()> which does the same thing:
# Create application and run it
go() ;
You can use whatever takes your fancy. Either way, the application object will end up calling the user-defined application subroutines
lib/App/Framework/Lite.pm view on Meta::CPAN
Called when B<app()> terminates or returns (usually of more use to extension developers)
=back
The framework looks for these 3 functions to be defined in the script file. The functions B<app_start> and B<app_end> are optional, but it is expected that B<app> will be defined
(otherwise nothing happens!).
=head3 Setup
The application settings are entered into the __DATA__ section at the end of the file. All program settings are grouped under sections which are introduced by '[section]' style headings. There are many
different settings that can be set using this mechanism, but the framework sets most of them to useful defaults.
For more details see L</Options> and L</Args>.
=head4 Summary
lib/App/Framework/Lite.pm view on Meta::CPAN
__DATA__
[SUMMARY]
An example of using the application framework
[ARGS]
* infile=f Input file
lib/App/Framework/Lite.pm view on Meta::CPAN
The parts of the specification are defined below.
=head4 name
The name defines the name of the key to use to access the argument value in the arguments hash. The application framework
passes a reference to the argument hash as the third parameter to the application subroutine B<app> (see L</Script Usage>)
=head4 specification
The specification is in the format:
lib/App/Framework/Lite.pm view on Meta::CPAN
Any string
=back
Additionally, an optional multiple can be specified. If used, this can only be specified on the last argument. When it is used, this tells the
application framework to use the last argument as an ARRAY, pushing all subsequent specified arguments onto this. Accessing the argument
in the script returns the ARRAY ref containing all of the command line argument values.
Multiple can be:
=over 4
lib/App/Framework/Lite.pm view on Meta::CPAN
One or more items
=item '*'
Zero or more items. There is also a special case (the real reason for *) where the argument specification is of the form '<f*' (input file multiple). Here, if the script user does not
specify any arguments on the command line for this argument then the framework opens STDIN and provides it as a file handle.
=back
=head4 summary
lib/App/Framework/Lite.pm view on Meta::CPAN
'file' => 'infile.txt'
'out' => 'outfile.txt'
'file_fh' => <file handle of 'infile.txt'>
'out_fh' => <file handle of 'outfile.txt'>
If this behaviour is not required, then you can get the framework to open just input files, output files, or none by using the 'open' option.
Specify this in the App::Framework 'use' line as an argument to the Args feature:
# Open no file handles
use App::Framework '+Args(open=none)' ;
lib/App/Framework/Lite.pm view on Meta::CPAN
=head2 Script Usage
The application framework passes a reference to the argument HASH as the third parameter to the application subroutine B<app>. Alternatively,
the script can call the app object's alias to the args accessor, i.e. the B<args> method which returns the arguments value list. Yet another
alternative is to call the args accessor method directly. These alternatives are shown below:
sub app
lib/App/Framework/Lite.pm view on Meta::CPAN
-<name><specification> <Summary> <optional default setting>
<Description>
These user-specified options are added to the application framework options (defined dependent on whatever core/features/extensions are installed).
Also, the user may over ride default settings and descriptions on any application framework options by re-defining them in the script.
The parts of the specification are defined below.
=head4 name
lib/App/Framework/Lite.pm view on Meta::CPAN
=back
=head3 Script Usage
The application framework passes a reference to the options HASH as the second parameter to the application subroutine B<app>. Alternatively,
the script can call the app object's alias to the options accessor, i.e. the B<options> method which returns the options hash. Yet another
alternative is to call the options accessor method directly. These alternatives are shown below:
sub app
lib/App/Framework/Lite.pm view on Meta::CPAN
Boolean option, accessed as $opts_href->{nomacro}
-log=s Override default [default=another default]
Over rides the default log option (specified by the framework)
-int=i An integer
Example of integer option
lib/App/Framework/Lite.pm view on Meta::CPAN
=head2 Data
After the settings (described above), one or more extra data areas can be created by starting that area with a new __DATA__ line.
The __DATA__ section at the end of the script is used by the application framework to allow the script developer to define
various settings for his/her script. This setup is split into "headed" sections of the form:
[ <section name> ]
<settings>
lib/App/Framework/Lite.pm view on Meta::CPAN
(Stored in the application's I<description> field).
=item B<[SYNOPSIS]> - Application synopsis [I<optional>]
Multiple line synopsis of the application usage. By default the application framework creates this if it is not specified.
(Stored in the application's I<synopsis> field).
=item B<[NAME]> - Application name [I<optional>]
Name of the application usage. By default the application framework creates this if it is not specified.
(Stored in the application's I<name> field).
=back
lib/App/Framework/Lite.pm view on Meta::CPAN
=item B<[OPTIONS]> - Application command line options
These are fully described in L<App::Framework::Features::Options>.
If no options are specified, then only those created by the application framework will be defined.
=item B<[ARGS]> - Application command line arguments [I<optional>]
These are fully described in L<App::Framework::Features::Args>.
lib/App/Framework/Lite.pm view on Meta::CPAN
=head2 Directories
The framework sets up various directory paths automatically, as described below.
=head3 @INC path
App::Framework automatically pushes some extra directories at the start of the Perl include library path. This allows you to 'use' application-specific
modules without having to install them globally on a system. The path of the executing Perl application is found by following any links until
lib/App/Framework/Lite.pm view on Meta::CPAN
* $progpath
* $progpath/lib
i.e. The directory that the script resides in, and a sub-directory 'lib' will be searched for application-specific modules.
Note that this is the path also used when the framework loads in the core personality, and any optional extensions.
=head2 EMBEDDING
lib/App/Framework/Lite.pm view on Meta::CPAN
Steve Price, C<< <sdprice at cpan.org> >>
=head1 BUGS
Please report any bugs or feature requests to C<bug-app-framework-lite at rt.cpan.org>, or through
the web interface at L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=App-Framework-Lite>. I will be notified, and then you'll
automatically be notified of progress on your bug as I make changes.
=head1 TODO
App-Framework
view release on metacpan or search on metacpan
examples/eg1.pl view on Meta::CPAN
28-May-08 SDP New
[SUMMARY]
An example of using the application framework with named arguments
[ARGS]
* src_dir=d Source directory
App-FzfUtils
view release on metacpan or search on metacpan
share/sample0.txt view on Meta::CPAN
blotter stater proustite keratoconjunctivitises assertor fragilities epilepsy sainting gentrifier stereotaxically unbounded trigged reichsmark overslips forebode bedight contrapuntally axmen pounding outstations taradiddles countertactics wagonette m...
moans downloads noctambulist hilt vasovagal rack palatal dogmaticalness aiders liturgiologists solion invigorate ventrally hooter eulogizer frizette methamphetamines worsened induing lankier packness tollhouse sings megadoses plasticizing fished auld...
chiasma subseres resurgences finances major margarin stomatic capelans gullying beflea broadly motorised systematically repopularizes choleras overvoted segmenting cosmopolises softheadednesses reflexively behaver reparative baize asthenospheres plus...
necrophilias procurement facially obeisance protectorates trijet graduates dreadlock descrying yamun intelligibilities kyphoses questioning impishness equablenesses restimulation druses phlebographic budless outbuying defats photolithographies tinman...
faultiest rassle orator tamer blacklisters dayworks fandom howlers archaebacteria wetback afferently contradistinctions coachmen uppercases isoniazids embryophytes delivers zaftig protohumans woozier outbloom klebsiella entomologically internationali...
inconsiderableness compares debutante waterzoois slake impuissance caesars orthopedically oxims upsprung pretrials framework beans miggles gnathite quiffs prevent frostwork resolutions heeder indie nonpossessions intimae fusilier conveyancing corrasi...
slyer strontias drosky frustules rented animated upstirs simulants differentiating carelessnesses halogenation cocktails spirillum scutate metronomes arcuately comprizes lushnesses stillbirth blent supersubtleties blacktops incurvates crepuscule jayw...
pneumatologies nonedible burg bonspells marijuanas recharter palaestra ditzes nuptial bracingly graphitizing lunately varletry demonizing iconolatry syllabub brazers bulking dichondras tattiness apophyllites medullated kashered mistrusts flaxiest ger...
mutts xylotomies remained gibbsite greenhorns elds outrated interstate wattages siziness savarin waterways plasmaphereses automatizes shelved timberman theatricalisms dismantling encyclopedisms neurologically doomsdayer cormel laicises rawins transdu...
instillments ganofs interlayer chowder putt coagulates frowzily emeerate vascular unpatentable cyphers outgnaws tributes sautoir demineralizer cadmium wantage neap glycosylated palingenesis doglegging preferring sponginess formulary pyrolize lengthen...
futurelessness thorned nonhunter robands scholastics haha jokesters fideists plonks tunelessly patience felspar mythoi euglobulin diminish orismology cleanups juristic epoxidizing kaif numbered saturated palpitates overlived replanning maced scaup vi...
App-GHGen
view release on metacpan or search on metacpan
lib/App/GHGen.pm view on Meta::CPAN
=head2 Test Dependencies
=over 4
=item * L<Test::More> - Testing framework
=item * L<Test::Exception> - Exception testing
=back
App-GUI-Cellgraph
view release on metacpan or search on metacpan
lib/App/GUI/Cellgraph.pm view on Meta::CPAN
use base qw/Wx::App/;
use App::GUI::Cellgraph::Frame;
sub OnInit {
my $app = shift;
my $frame = App::GUI::Cellgraph::Frame->new( undef, 'Cellgraph '.$VERSION);
$frame->Show(1);
$frame->CenterOnScreen();
$app->SetTopWindow($frame);
1;
}
sub OnQuit { my( $self, $event ) = @_; $self->Close( 1 ); }
sub OnExit { my $app = shift; 1; }
lib/App/GUI/Cellgraph.pm view on Meta::CPAN
</p>
The first tab contains settings, that shape the drawing in the most broad way.
It is segmented into three parts that somewhat parallel the last three tabs.
The topmost section sets the framework for rules by which the cell state
changes - computation round by computation round. B<Input Size> appoints
the size of neighbourhood, the left side of an subrule. If you set it to
an odd number like 5, then the cells current state plus its two neighbours
on each side determine the next state of a cell. But if you set it to an
even number like 2 then only one neighbour on each side has this power,
lib/App/GUI/Cellgraph.pm view on Meta::CPAN
But if you activate the option B<Circular>, then the left neighbour of
the leftmost cell is the rightmost cell and vice versa. This can fix
certain types of irregularities in the drawing.
The middle section sets the framework for the action rules, which change
the activity value of a cell. The activity value can never be below zero
or above one. The B<Apply> option activates the aplication of action rules.
And if action rules are in effect then the state of a cell can only change,
if the activity value is equal or above the B<Threshold>. Action rules
react to the same input pattern as state rules. However, the result of
App-GUI-Harmonograph
view release on metacpan or search on metacpan
lib/App/GUI/Harmonograph.pm view on Meta::CPAN
use base qw/Wx::App/;
use App::GUI::Harmonograph::Frame;
sub OnInit {
my $app = shift;
my $frame = App::GUI::Harmonograph::Frame->new( undef, 'Harmonograph '.$VERSION);
$frame->Show(1);
$frame->CenterOnScreen();
$app->SetTopWindow($frame);
1;
}
sub OnQuit { my( $self, $event ) = @_; $self->Close( 1 ); }
sub OnExit { my $app = shift; 1; }
lib/App/GUI/Harmonograph.pm view on Meta::CPAN
towards the other pendula. Natural constants are also here available as
a factor and behind the on the most right is a button to reset the
radius to 100 percent.
The seventh row is the amplitude size, which simple allows to make the
picture larger or smaller depending if the pendulum left the frame or
doesn't move enough. As with reqency, also the amplitude can be damped
over time and this damping can accelerated.
Row eight and nine are exact copies of row three and four, they just
affect the radius / amplitude.
App-GUI-Juliagraph
view release on metacpan or search on metacpan
lib/App/GUI/Juliagraph.pm view on Meta::CPAN
use base qw/Wx::App/;
use App::GUI::Juliagraph::Frame;
sub OnInit {
my $app = shift;
my $frame = App::GUI::Juliagraph::Frame->new( undef, 'Juliagraph '.$VERSION);
$frame->Show(1);
$frame->CenterOnScreen();
$app->SetTopWindow($frame);
1;
}
sub OnQuit { my( $self, $event ) = @_; $self->Close( 1 ); }
sub OnExit { my $app = shift; 1; }
App-GUI-Notepad
view release on metacpan or search on metacpan
lib/App/GUI/Notepad.pm view on Meta::CPAN
sub OnInit {
my ($this) = @_;
Wx::InitAllImageHandlers();
my ($frame) = App::GUI::Notepad::Frame->new(
"Perlpad",
Wx::Point->new( 50, 50 ),
Wx::Size->new( 450, 350 )
);
$this->{frame} = $frame;
$this->SetTopWindow($frame);
$frame->Show(1);
$this;
}
1;
App-GitFind
view release on metacpan or search on metacpan
lib/App/GitFind/Class.pm view on Meta::CPAN
my $class = shift or require Carp, Carp::croak 'Need a class';
if(@_ == 1 && ref $_[0] eq 'HASH') {
@_ = ($class, %{$_[0]});
goto \&_app_gitfind_class_builder_internal;
# No extra stack frame for the sake of croak()
} elsif(@_ == 1 && ref $_[0]) {
require Carp;
Carp::croak "$class\->new(arg) with @{[ref $_[0]]} instead of HASH ref";
} elsif(@_ % 2) {
require Carp;
App-GitGerrit
view release on metacpan or search on metacpan
bin/git-gerrit view on Meta::CPAN
Strawberry Perl. Your mileage may vary, though.
=head1 CONFIGURATION
Git-gerrit is configured through Git's standard configuration
framework, which you can read about with the C<git help config>
command. All git-gerrit's configuration variables are in the
C<git-gerrit> section and can be created at the C<system>, the
C<global>, or the C<local> level. More specifically, git-gerrit groks
its configuration from the output of the C<git config -l> command.
( run in 2.050 seconds using v1.01-cache-2.11-cpan-e1769b4cff6 )