view release on metacpan or search on metacpan
separated list of filters, only hosts/services to which all filters apply are
selected. See also L</"FILTER EXPRESSIONS">
=back
=head1 OUTPUT
=head2 SERVICE LISTING
This is the standard output method. It contains the following:
view release on metacpan or search on metacpan
lib/App/Iops.pm view on Meta::CPAN
}
sub _watch_iops {
my ($self) = @_;
$OUTPUT_AUTOFLUSH = -t STDOUT;
local $/ = "\n";
while ( my $iop = readline $self->{strace_fh} ) {
chomp $iop;
view release on metacpan or search on metacpan
lib/App/Iptables2Dot.pm view on Meta::CPAN
# Returns a list of all internal tables.
#
sub _internal_nodes {
my $self = shift;
my $opt = shift;
my $re_in = qr/^(PREROUTING|POSTROUTING|INPUT|FORWARD|OUTPUT)$/;
my @nodes = ();
my %have_node = ();
my %used = ();
foreach my $table (@_) {
unless ($opt->{showunusednodes} || $opt->{"use-numbered-nodes"}) {
view release on metacpan or search on metacpan
scripts/jiraprint view on Meta::CPAN
unless( $output ){
binmode STDOUT, ':utf8';
print $j->process_template();
}else{
open OUTPUT , '>' , $output;
binmode OUTPUT , ':utf8';
print OUTPUT $j->process_template();
close OUTPUT;
$log->info("XeTeX file written to $output. Now run xelatex $output to generate your PDF.");
}
__END__
view release on metacpan or search on metacpan
lib/App/LWPUtils.pm view on Meta::CPAN
cmdline_aliases => {
delete => {summary => 'Shortcut for --method DELETE', is_flag=>1, code=>sub { $_[0]{method} = 'DELETE' } },
get => {summary => 'Shortcut for --method GET' , is_flag=>1, code=>sub { $_[0]{method} = 'GET' } },
head => {summary => 'Shortcut for --method HEAD' , is_flag=>1, code=>sub { $_[0]{method} = 'HEAD' } },
post => {summary => 'Shortcut for --method POST' , is_flag=>1, code=>sub { $_[0]{method} = 'POST' } },
put => {summary => 'Shortcut for --method PUT' , is_flag=>1, code=>sub { $_[0]{method} = 'PUT' } },
},
},
attributes => {
'x.name.is_plural' => 1,
'x.name.singular' => 'attribute',
view release on metacpan or search on metacpan
lib/App/Lastmsg.pm view on Meta::CPAN
use Date::Parse;
use Email::Folder;
use List::Util qw/max/;
use POSIX qw/strftime/;
our $OUTPUT_FILEHANDLE = \*STDOUT;
our $VERSION = '0.002001';
our @DEFAULT_INBOX;
push @DEFAULT_INBOX, "/var/mail/$ENV{USER}" if exists $ENV{USER};
push @DEFAULT_INBOX, "$ENV{HOME}/Maildir" if exists $ENV{HOME};
lib/App/Lastmsg.pm view on Meta::CPAN
my $idlen = max map { length } keys %track;
my $addrlen = max map { length } values %lastaddr;
for (sort { $lastmsg{$b} <=> $lastmsg{$a} } keys %lastmsg) {
my $time = format_time $lastmsg{$_};
printf $OUTPUT_FILEHANDLE "%-${idlen}s %-${addrlen}s %s\n", $_, $lastaddr{$_}, $time;
}
for (grep { !exists $lastmsg{$_} } sort keys %track) {
printf $OUTPUT_FILEHANDLE "%-${idlen}s %-${addrlen}s NOT FOUND\n", $_, ''
}
}
1;
__END__
view release on metacpan or search on metacpan
lib/App/LinkSite.pm view on Meta::CPAN
$tt = Template->new({
# Templates in the CPAN distro directory
INCLUDE_PATH => $src,
# Output in the data directory
OUTPUT_PATH => $out,
VARIABLES => {
ga4 => $ga4,
}
});
view release on metacpan or search on metacpan
use MARC::Leader;
use MARC::Leader::Utils qw(material_type);
use Readonly;
use Unicode::UTF8 qw(encode_utf8 decode_utf8);
Readonly::Array our @OUTPUT_FORMATS => qw(ascii xml);
Readonly::Array our @CONTROL_FIELDS => qw(001 003 005 006 007 008);
our $VERSION = 0.06;
$| = 1;
} else {
$self->{'_marc_value'} = decode_utf8($self->{'_marc_value'});
}
# Check output format.
if (none { $self->{'_opts'}->{'o'} eq $_ } @OUTPUT_FORMATS) {
err "Output format '$self->{'_opts'}->{'o'}' doesn't supported.";
}
my $marc_file = MARC::File::XML->in($self->{'_marc_xml_file'});
my @ret;
view release on metacpan or search on metacpan
use MARC::File::XML (BinaryEncoding => 'utf8', RecordFormat => 'MARC21');
use MARC::Record::Stats;
use Readonly;
use Unicode::UTF8 qw(encode_utf8);
Readonly::Array our @INPUT_FORMATS => qw(xml);
our $VERSION = 0.01;
# Constructor.
sub new {
return 1;
}
$self->{'_marc_file'} = shift @ARGV;
# Check output format.
if (none { $self->{'_opts'}->{'i'} eq $_ } @INPUT_FORMATS) {
err "Input format '$self->{'_opts'}->{'i'}' doesn't supported.";
}
my $stats = MARC::Record::Stats->new;
view release on metacpan or search on metacpan
lib/App/MBUtiny/Collector/Server.pm view on Meta::CPAN
$self->{_time} = sprintf("%.4f", $self->tms(1))*1;
return HTTP_INTERNAL_SERVER_ERROR unless $self->status;
# Prepare input data
my $meth = $self->info->{method} || "GET";
if ($meth =~ /POST|PUT|PATCH/) {
my $data = $q->param($meth."DATA") // $q->param('XForms:Model');
Encode::_utf8_on($data);
if (value($self->info("attrs"), "deserialize")) {
my $serializer = $self->serializer;
$self->data($serializer->deserialize($data));
view release on metacpan or search on metacpan
lib/App/MFILE/WWW/Resource.pm view on Meta::CPAN
use App::CELL qw( $CELL $log $meta $site );
use Data::Dumper;
use Encode qw( decode_utf8 encode_utf8 );
use File::Temp qw( tempfile );
use HTTP::Request::Common qw( GET PUT POST DELETE );
use JSON;
use LWP::UserAgent;
use Params::Validate qw(:all);
use Try::Tiny;
lib/App/MFILE/WWW/Resource.pm view on Meta::CPAN
# process arguments
my $ua = $self->ua();
die "Bad user agent object" unless ref( $ua ) eq 'LWP::UserAgent';
my %ARGS = validate( @_, {
server => { type => SCALAR, default => 'http://localhost:5000' },
method => { type => SCALAR, default => 'GET', regex => qr/^(GET|POST|PUT|DELETE)$/ },
nick => { type => SCALAR, optional => 1 },
password => { type => SCALAR, default => '' },
path => { type => SCALAR, default => '/' },
req_body => { type => HASHREF, optional => 1 },
} );
lib/App/MFILE/WWW/Resource.pm view on Meta::CPAN
if ( $ARGS{'nick'} ) {
$r->authorization_basic( $ARGS{'nick'}, $ARGS{'password'} );
}
if ( $ARGS{'method'} =~ m/^(POST|PUT)$/ ) {
$r->header( 'Content-Type' => 'application/json' );
if ( my $body = $ARGS{'req_body'} ) {
my $tmpvar = JSON->new->utf8(0)->encode( $body );
$r->content( encode_utf8( $tmpvar ) );
}
view release on metacpan or search on metacpan
lib/App/MFILE/HTTP.pm view on Meta::CPAN
use App::CELL qw( $CELL $log $site $meta );
use Data::Dumper;
use Encode qw( encode_utf8 );
use Exporter qw( import );
use HTTP::Request::Common qw( GET PUT POST DELETE );
use JSON;
use LWP::UserAgent;
use Params::Validate qw( :all );
use Try::Tiny;
lib/App/MFILE/HTTP.pm view on Meta::CPAN
# process arguments
my $ua = shift;
die "Bad user agent object" unless ref( $ua ) eq 'LWP::UserAgent';
my %ARGS = validate( @_, {
server => { type => SCALAR, default => 'http://localhost:5000' },
method => { type => SCALAR, default => 'GET', regex => qr/^(GET|POST|PUT|DELETE)$/ },
nick => { type => SCALAR, optional => 1 },
password => { type => SCALAR, default => '' },
path => { type => SCALAR, default => '/' },
req_body => { type => HASHREF, optional => 1 },
} );
lib/App/MFILE/HTTP.pm view on Meta::CPAN
if ( $ARGS{'nick'} ) {
$r->authorization_basic( $ARGS{'nick'}, $ARGS{'password'} );
}
if ( $ARGS{'method'} =~ m/^(POST|PUT)$/ ) {
$r->header( 'Content-Type' => 'application/json' );
if ( my $body = $ARGS{'req_body'} ) {
my $tmpvar = JSON->new->utf8(0)->encode( $body );
$r->content( encode_utf8( $tmpvar ) );
}
view release on metacpan or search on metacpan
lib/App/MHFS.pm view on Meta::CPAN
$self->{'httpproto'} = $4;
my $rid = int(clock_gettime(CLOCK_MONOTONIC) * rand()); # insecure uid
$self->{'outheaders'}{'X-MHFS-REQUEST-ID'} = sprintf("%X", $rid);
say "X-MHFS-CONN-ID: " . $self->{'outheaders'}{'X-MHFS-CONN-ID'} . " X-MHFS-REQUEST-ID: " . $self->{'outheaders'}{'X-MHFS-REQUEST-ID'};
say "RECV: $rl";
if(($self->{'method'} ne 'GET') && ($self->{'method'} ne 'HEAD') && ($self->{'method'} ne 'PUT')) {
say "X-MHFS-CONN-ID: " . $self->{'outheaders'}{'X-MHFS-CONN-ID'} . 'Invalid method: ' . $self->{'method'}. ', closing conn';
return undef;
}
my ($path, $querystring) = ($self->{'uri'} =~ /^([^\?]+)(?:\?)?(.*)$/g);
say("raw path: $path\nraw querystring: $querystring");
lib/App/MHFS.pm view on Meta::CPAN
}
}
$self->Send404;
}
sub PUTBuf_old {
my ($self, $handler) = @_;
if(length($self->{'client'}{'inbuf'}) < $self->{'header'}{'Content-Length'}) {
$self->{'client'}->SetEvents(POLLIN | MHFS::EventLoop::Poll->ALWAYSMASK );
}
my $sdata;
$self->{'on_read_ready'} = sub {
my $contentlength = $self->{'header'}{'Content-Length'};
$sdata .= $self->{'client'}{'inbuf'};
my $dlength = length($sdata);
if($dlength >= $contentlength) {
say 'PUTBuf datalength ' . $dlength;
my $data;
if($dlength > $contentlength) {
$data = substr($sdata, 0, $contentlength);
$self->{'client'}{'inbuf'} = substr($sdata, $contentlength);
$dlength = length($data)
lib/App/MHFS.pm view on Meta::CPAN
return 1;
};
$self->{'on_read_ready'}->();
}
sub PUTBuf {
my ($self, $handler) = @_;
if($self->{'header'}{'Content-Length'} > 20000000) {
say "PUTBuf too big";
$self->{'client'}->SetEvents(POLLIN | MHFS::EventLoop::Poll->ALWAYSMASK );
$self->{'on_read_ready'} = sub { return undef };
return;
}
if(length($self->{'client'}{'inbuf'}) < $self->{'header'}{'Content-Length'}) {
lib/App/MHFS.pm view on Meta::CPAN
}
$self->{'on_read_ready'} = sub {
my $contentlength = $self->{'header'}{'Content-Length'};
my $dlength = length($self->{'client'}{'inbuf'});
if($dlength >= $contentlength) {
say 'PUTBuf datalength ' . $dlength;
my $data;
if($dlength > $contentlength) {
$data = substr($self->{'client'}{'inbuf'}, 0, $contentlength, '');
}
else {
view release on metacpan or search on metacpan
script/mtputils-del-files view on Meta::CPAN
log_level (see --log-level)
naked_res (see --naked-res)
=head1 ENVIRONMENT
=head2 MTPUTILS_DEL_FILES_OPT => str
Specify additional command-line options.
=head1 FILES
view release on metacpan or search on metacpan
lib/App/Magpie/Action/Old.pm view on Meta::CPAN
sub run {
my ($self) = @_;
my %category;
my $outfile = path( "/tmp/cpan-o.stdout" );
if ( $ENV{MAGPIE_REUSE_CPAN_O_OUTPUT} ) {
$self->log( "re-using cpan -O output from $outfile" );
} else {
my $cmd = "cpan -O >$outfile 2>/tmp/cpan-o.stderr";
$self->log( "running: $cmd" );
system("$cmd") == 0
view release on metacpan or search on metacpan
char *
LIBTRACER_SO()
CODE:
RETVAL = LIBTRACER_SO;
OUTPUT:
RETVAL
char *
LIBDIR()
CODE:
RETVAL = LIBDIR;
OUTPUT:
RETVAL
# damn, POSIX doesn't include S_ISLNK!
void
view release on metacpan or search on metacpan
t/01-simple.t view on Meta::CPAN
my $keep;
my $format;
BEGIN
{
defined $ENV{KEEP_TEST_OUTPUT} and $keep = $ENV{KEEP_TEST_OUTPUT};
defined $ENV{TEST_OUTPUT_TYPE} and $format = $ENV{TEST_OUTPUT_TYPE};
if ( defined( $ENV{TEST_DIR} ) )
{
$test_dir = $ENV{TEST_DIR};
-d $test_dir or mkpath $test_dir;
$keep = 1;
view release on metacpan or search on metacpan
lib/App/MatrixTool/Command/client/json.pm view on Meta::CPAN
C<matrixtool client login>) then it is automatically added to the query
parameters as well.
An optional second argument, I<DATA>, may be provided. If so, this should
contain a JSON encoding of data to supply with the request, turning it into a
C<PUT> request. If no data is supplied, then a C<GET> request is performed
instead.
The resulting JSON data from the homeserver is parsed and re-printed in a more
human-readable form to standard output. Linefeeds and indentation whitespace
are used to increase readability.
lib/App/MatrixTool/Command/client/json.pm view on Meta::CPAN
=over 4
=item C<--method>, C<-m>
Use a different HTTP method. If not specified, C<GET> or C<PUT> will be
performed, depending on whether the I<DATA> argument was supplied.
=back
=cut
lib/App/MatrixTool/Command/client/json.pm view on Meta::CPAN
{
my $self = shift;
my ( $opts, $pathquery, $data ) = @_;
my $method = "GET";
$method = "PUT" if defined $data;
$method = $opts->{method} if defined $opts->{method};
my %opts;
lib/App/MatrixTool/Command/client/json.pm view on Meta::CPAN
"avatar_url": "mxc://example.com/aBcDeFgHiJ...",
"displayname": "Mr Example",
}
By supplying a second parameter containing JSON-encoded data, we can perform
a C<PUT> request to update the displayname:
$ matrixtool client -u @me:example.com json \
/_matrix/client/r0/profile/@me:example.com/displayname \
'{"displayname":"Mr. Example"}'
{}
view release on metacpan or search on metacpan
lib/App/Midgen.pm view on Meta::CPAN
use version;
our $VERSION = '0.34';
$VERSION = eval $VERSION; ## no critic
use English qw( -no_match_vars ); # Avoids reg-ex performance penalty
local $OUTPUT_AUTOFLUSH = 1;
use Cwd qw(getcwd);
use Data::Printer {caller_info => 1,};
use File::Find qw(find);
use File::Spec;
view release on metacpan or search on metacpan
/var/db/milter-limit.
You also need to tell sendmail about the milter. Add something like the
following to your sendmail.mc and generate a new sendmail.cf:
INPUT_MAIL_FILTER(`milter-limit', `S=local:/var/run/milter-limit.sock')
Finally, you need to arrage for the milter to start at boot time. some init
scripts are available in the contrib directory.
COPYRIGHT AND LICENSE
view release on metacpan or search on metacpan
root/js/ext-3.3.1/ext-all.js view on Meta::CPAN
* Ext JS Library 3.3.1
* Copyright(c) 2006-2010 Sencha Inc.
* licensing@sencha.com
* http://www.sencha.com/license
*/
(function(){var h=Ext.util,k=Ext.each,g=true,i=false;h.Observable=function(){var l=this,m=l.events;if(l.listeners){l.on(l.listeners);delete l.listeners}l.events=m||{}};h.Observable.prototype={filterOptRe:/^(?:scope|delay|buffer|single)$/,fireEvent:fu...
/* SWFObject v2.2 <http://code.google.com/p/swfobject/>
is released under the MIT License <http://www.opensource.org/licenses/mit-license.php>
*/
var swfobject=function(){var F="undefined",t="object",U="Shockwave Flash",Y="ShockwaveFlash.ShockwaveFlash",s="application/x-shockwave-flash",T="SWFObjectExprInst",z="onreadystatechange",Q=window,l=document,v=navigator,V=false,W=[i],q=[],P=[],K=[],n,...
view release on metacpan or search on metacpan
lib/App/Module/Template.pm view on Meta::CPAN
my $config_file = _get_config_path($opt{c}, $template_dir);
my $cfg = _get_config($config_file);
# Setting this lets TT2 handle creating the destination files/directories
$cfg->{template_toolkit}{OUTPUT_PATH} = $dist_dir;
my $tt2 = Template->new( $cfg->{template_toolkit} );
# don't need this in the $tmpl_vars
delete $cfg->{template_toolkit};
view release on metacpan or search on metacpan
script/mbtiny view on Meta::CPAN
=head2 version
This prints the version of C<mbtiny>.
=head1 INPUTS
The metadata for the distribution is gathered from various sources.
=over 4
view release on metacpan or search on metacpan
lib/App/MojoSlides/files/public/mousetrap.min.js view on Meta::CPAN
l[a][g],!(!d&&k.seq&&n[k.seq]!=k.level||h!=k.action||("keypress"!=h||c.metaKey||c.ctrlKey)&&b.sort().join(",")!==k.modifiers.sort().join(","))){var m=d&&k.seq==d&&k.level==v;(!d&&k.combo==e||m)&&l[a].splice(g,1);f.push(k)}return f}function K(a){var b...
b.returnValue=!1,b.cancelBubble=!0)}function y(a){"number"!==typeof a.which&&(a.which=a.keyCode);var b=A(a);b&&("keyup"==a.type&&z===b?z=!1:m.handleKey(b,K(a),a))}function w(a){return"shift"==a||"ctrl"==a||"alt"==a||"meta"==a}function L(a,b,c,d){func...
d,e,f=[];c="+"===a?["+"]:a.split("+");for(e=0;e<c.length;++e)d=c[e],G[d]&&(d=G[d]),b&&"keypress"!=b&&H[d]&&(d=H[d],f.push("shift")),w(d)&&f.push(d);c=d;e=b;if(!e){if(!p){p={};for(var g in h)95<g&&112>g||h.hasOwnProperty(g)&&(p[h[g]]=g)}e=p[c]?"keydow...
d,a,e),l[c.key][d?"unshift":"push"]({callback:b,modifiers:c.modifiers,action:c.action,seq:d,level:e,combo:a}))}var h={8:"backspace",9:"tab",13:"enter",16:"shift",17:"ctrl",18:"alt",20:"capslock",27:"esc",32:"space",33:"pageup",34:"pagedown",35:"end",...
"@":"2","#":"3",$:"4","%":"5","^":"6","&":"7","*":"8","(":"9",")":"0",_:"-","+":"=",":":";",'"':"'","<":",",">":".","?":"/","|":"\\"},G={option:"alt",command:"meta","return":"enter",escape:"esc",mod:/Mac|iPod|iPhone|iPad/.test(navigator.platform)?"me...
unbind:function(a,b){return m.bind(a,function(){},b)},trigger:function(a,b){if(q[a+":"+b])q[a+":"+b]({},a);return this},reset:function(){l={};q={};return this},stopCallback:function(a,b){return-1<(" "+b.className+" ").indexOf(" mousetrap ")?!1:"INPUT...
b[d[e].seq]=1,x(d[e].callback,c,d[e].combo)):g||x(d[e].callback,c,d[e].combo);d="keypress"==c.type&&I;c.type!=u||w(a)||d||t(b);I=g&&"keydown"==c.type}};J.Mousetrap=m;"function"===typeof define&&define.amd&&define(m)})(window,document);
view release on metacpan or search on metacpan
lib/App/MonM/Checkit/HTTP.pm view on Meta::CPAN
=item B<Content>
Content "Content for HTTP request"
Specifies POST/PUT/PATCH request content
Example:
Set Content-Type text/plain
Content "Content for POST HTTP request"
lib/App/MonM/Checkit/HTTP.pm view on Meta::CPAN
=item B<Method>
Method GET
Defines the HTTP method: GET, POST, PUT, HEAD, PATCH, DELETE, and etc.
Default: GET
=item B<Proxy>
lib/App/MonM/Checkit/HTTP.pm view on Meta::CPAN
# Proxy
$ua->proxy(['http', 'https'], $proxy) if $proxy;
# Prepare request data
my $request = HTTP::Request->new(uc($method) => $uri);
if ($method =~ /PUT|POST|PATCH/) {
Encode::_utf8_on($content);
$request->header('Content-Length' => length(Encode::encode("utf8", $content)));
$request->content(Encode::encode("utf8", $content));
}
view release on metacpan or search on metacpan
.synTodo { color: #0000FF ; background: #FFFF00 none }
(taken from Text::VimColor)
VERBATIM OUTPUT
If your website includes string like [% or %] etc., you can use the
verbatim-construct to prevent it from parsing:
[% verbatim foobarbaz %]
view release on metacpan or search on metacpan
lib/App/MtAws/GlacierRequest.pm view on Meta::CPAN
($self->{part_final_hash} = $part_final_hash)||confess;
$self->_calc_data_hash;
$self->{url} = "/$self->{account_id}/vaults/$self->{vault}/multipart-uploads/$uploadid";
$self->{method} = 'PUT';
$self->add_header('Content-Type', 'application/octet-stream');
$self->add_header('Content-Length', length(${$self->{dataref}}));
$self->add_header('x-amz-content-sha256', $self->{data_sha256});
$self->add_header('x-amz-sha256-tree-hash', $self->{part_final_hash});
my ($start, $end) = ($offset, $offset+length(${$self->{dataref}})-1 );
lib/App/MtAws/GlacierRequest.pm view on Meta::CPAN
my ($self, $vault_name) = @_;
confess unless defined($vault_name);
$self->{url} = "/$self->{account_id}/vaults/$vault_name";
$self->{method} = 'PUT';
my $resp = $self->perform_lwp();
return $resp ? $resp->header('x-amzn-RequestId') : undef;
}
lib/App/MtAws/GlacierRequest.pm view on Meta::CPAN
} else {
$ua->ssl_opts( verify_hostname => 1, SSL_verify_mode=>1);
}
}
$url .= "?$self->{params_s}" if $self->{params_s};
if ($self->{method} eq 'PUT') {
$req = HTTP::Request->new(PUT => $url, undef, $self->{dataref});
} elsif ($self->{method} eq 'POST') {
if ($self->{dataref}) {
$req = HTTP::Request->new(POST => $url, [Content_Type => 'form-data'], ${$self->{dataref}});
} else {
$req = HTTP::Request->new(POST => $url );
view release on metacpan or search on metacpan
lib/App/Multigit.pm view on Meta::CPAN
Defaults to true; this should be used by scripts to determine whether to bother
mentioning repositories that gave no output at all for the given task. If you
use C<App::Multigit::Repo::report>, this will be honoured by default.
Controlled by the C<MG_REPORT_ON_NO_OUTPUT> environment variable.
=head3 ignore_stdout
=head3 ignore_stderr
lib/App/Multigit.pm view on Meta::CPAN
Controlled by the C<MG_SKIP_READONLY> environment variable.
=cut
our %BEHAVIOUR = (
report_on_no_output => $ENV{MG_REPORT_ON_NO_OUTPUT} // 1,
ignore_stdout => !!$ENV{MG_IGNORE_STDOUT},
ignore_stderr => !!$ENV{MG_IGNORE_STDERR},
concurrent => $ENV{MG_CONCURRENT_PROCESSES} // 20,
skip_readonly => !!$ENV{MG_SKIP_READONLY},
output_only => !!$ENV{MG_OUTPUT_ONLY},
);
=head2 @SELECTED_REPOS
If this is not empty, it should contain paths to repositories. Relative paths
view release on metacpan or search on metacpan
lib/ChordPro.pm view on Meta::CPAN
# Shortcut a2crd conversion.
if ( $options->{a2crd} ) {
require ChordPro::A2Crd;
$res = ChordPro::A2Crd::a2crd();
push( @$res, '' );
goto WRITE_OUTPUT;
}
# Check for metadata in filelist. Actually, this works on the
# command line as well, but don't tell anybody.
progress( phase => "Parsing", index => 0, total => 0+@ARGV )
lib/ChordPro.pm view on Meta::CPAN
# Call backend to produce output.
$res = $pkg->generate_songbook($s);
return $res if $options->{output} eq '*';
WRITE_OUTPUT:
# Some backends write output themselves, others return an
# array of lines to be written.
if ( $res && @$res > 0 ) {
if ( $of && $of ne "-" ) {
open( my $fd, '>', $of );
view release on metacpan or search on metacpan
lib/App/Music/PlayTab.pm view on Meta::CPAN
app_options();
binmode( STDERR, ':utf8' );
print STDOUT ("ok 1\n") if $test;
if ( defined $output ) {
open(OUTPUT, ">$output") or print STDOUT ("not ") if $test;
print STDOUT ("ok 2\n") if $test;
}
else {
die("Test mode requires -output option to be set\n") if $test;
*OUTPUT = *STDOUT;
}
# Options post-processing.
$trace |= ($debug || $test);
$xpose = $gxpose;
lib/App/Music/PlayTab.pm view on Meta::CPAN
print STDOUT ("ok 4\n") if $test;
print STDOUT ("ok 5\n") if $test;
close OUTPUT if defined $output;
exit 0 unless $test;
}
sub push_entry {
return unless $entry && keys(%$entry);
lib/App/Music/PlayTab.pm view on Meta::CPAN
Input file(s).
=back
=head1 INPUT SYNTAX
The input for playtab is plain ASCII. It contains the chords, the
division in bars, with optional annotations.
An example:
lib/App/Music/PlayTab.pm view on Meta::CPAN
Oh, I almost forgot: it can print guitar chord diagrams as well.
See "bluebossa", "sophisticatedlady" and some others.
Have fun, and let me know your ideas!
=head1 INPUT SYNTAX
Notes: C, D, E, F, G, A, B.
Raised with '#' or suffix 'is', e.g. A#, Ais.
Lowered with 'b' or suffix 's' or 'es', e.g. Bes, As, Eb.
lib/App/Music/PlayTab.pm view on Meta::CPAN
: Repeats previous chord
% Repeat
/ Powerchord constructor [D/G D/E-]
--------------------------------------------------------------
=head1 LILYPOND INPUT SYNTAX
Notes: c, d, e, f, g, a, b.
Raised with suffix 'is', e.g. ais.
Lowered with suffix 'es', e.g. bes, ees.