view release on metacpan or search on metacpan
lib/App/TimelogTxt/Utils.pm view on Meta::CPAN
sub day_stamp
{
my ( $day ) = @_;
return today_stamp() if is_today( $day );
# Parse the string to generate a reasonable guess for the day.
return canonical_datestamp( $day ) if is_datestamp( $day );
$day = lc $day;
return unless grep { $day eq $_ } $YESTERDAY, @DAYS;
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
if ( @Missing and not( $CheckOnly or $UnderCPAN ) ) {
require Config;
print
"*** Dependencies will be installed the next time you type '$Config::Config{make}'.\n";
# make an educated guess of whether we'll need root permission.
print " (You may need to do that as the 'root' user.)\n"
if eval '$>';
}
print "*** $class configuration finished.\n";
inc/Module/AutoInstall.pm view on Meta::CPAN
or _load('CPANPLUS::Shell::Default')
)
);
}
# make guesses on whether we're under the CPAN installation directory
sub _under_cpan {
require Cwd;
require File::Spec;
my $cwd = File::Spec->canonpath( Cwd::cwd() );
view release on metacpan or search on metacpan
lib/App/WRT/Sort.pm view on Meta::CPAN
my @parts = map {
my $padded;
if (m/^\d+$/) {
# There's a year 100k bug here, but I guess I'll cross that bridge when I
# come to it:
$padded = sprintf("%05d", $_);
} else {
$padded = $_;
}
view release on metacpan or search on metacpan
lib/App/Wax.pm view on Meta::CPAN
my $name = $self->app_name;
my $message = @args ? sprintf($template, @args) : $template;
warn "$name: $level: $message", $/;
}
# return a best-effort guess at the URL's file extension based on its content
# type, e.g. ".md" or ".tar.gz", or an empty string if one can't be determined.
# XXX note: makes a network request to determine the content type
method extension ($_url) {
my ($url, $url_index) = @$_url;
my $extension = '';
view release on metacpan or search on metacpan
=head1 DESCRIPTION
C<yg> is a log viewer(filter) to show log lines vertically.
When you check apache logs, I guess you do like this
$ cat apache_log
127.0.0.1 - - [30/Sep/2012:12:34:56 +0900] "GET /foo HTTP/1.0" 200 123 "http://example.com/foo" "Mozilla/5.0"
127.0.0.1 - - [30/Sep/2012:12:34:57 +0900] "GET /bar HTTP/1.0" 301 124 "http://example.com/bar" "Mozilla/5.1"
view release on metacpan or search on metacpan
script/_chinese-zodiac-of view on Meta::CPAN
# my $self = shift;
# $self->{stream} .= join '', @_;
#}
#
## Emit a string value. YAML has many scalar styles. This routine attempts to
## guess the best style for the text.
#sub _emit_str {
# my $self = shift;
# my $type = $_[1] || 0;
#
# # Use heuristics to find the best scalar emission style.
view release on metacpan or search on metacpan
lib/App/ZofCMS/Plugin/DBIPPT.pm view on Meta::CPAN
Ok, the name C<DBIPPT> isn't the most clear choice for the name of
the plugin, but when I first wrote out the full name I realized that
the name alone defeats the purpose of the plugin - saving keystrokes -
so I shortened it from C<DBIPostProcessLargeText> to C<DBIPPT> (the C<L>
was lost in "translation" as well). If you're suffering from memory
problems, I guess one way to remember the name is "B<P>lease B<Process>
B<This>".
=head1 FIRST-LEVEL ZofCMS TEMPLATE AND MAIN CONFIG FILE KEYS
=head2 C<plugins>
view release on metacpan or search on metacpan
lib/App/a2p.pm view on Meta::CPAN
in. You may wish to remove it.
Perl differentiates numeric comparison from string comparison. Awk
has one operator for both that decides at run time which comparison to
do. A2p does not try to do a complete job of awk emulation at this
point. Instead it guesses which one you want. It's almost always
right, but it can be spoofed. All such guesses are marked with the
comment "C<#???>". You should go through and check them. You might
want to run at least once with the B<-w> switch to perl, which will
warn you if you use == where you should have used eq.
Perl does not attempt to emulate the behavior of awk in which
lib/App/a2p.pm view on Meta::CPAN
=head1 BUGS
It would be possible to emulate awk's behavior in selecting string
versus numeric operations at run time by inspection of the operands,
but it would be gross and inefficient. Besides, a2p almost always
guesses right.
Storage for the awk syntax tree is currently static, and can run out.
view release on metacpan or search on metacpan
0.003 2012-11-13 22:08:29 Europe/Berlin
[BUGS]
Corrected a minor bug in a test: I guessed the order of directory entries.
Thanks to CPAN Testers this was caught.
The POD for autotest contained duplicate entries since I typed (manually)
what Dist::Zilla adds (automatically).
view release on metacpan or search on metacpan
aclocal.m4
announce-gen
autogen.sh
bootstrap
compile
config.guess
config.h.in
config.rpath
config.status
config.sub
configure
# Note that /usr/src/redhat/BUILD/ucd-snmp-4.1.1/ov/bitmaps/UCD.20.p
# is actually C code. The heuristics determine that they're not Pascal,
# but because it ends in ".p" it's not counted as C code either.
# I believe this is actually correct behavior, because frankly it
# looks like it's automatically generated (it's a bitmap expressed as code).
# Rather than guess otherwise, we don't include it in a list of
# source files. Let's face it, someone who creates C files ending in ".p"
# and expects them to be counted by default as C files in SLOCCount needs
# their head examined. I suggest examining their head
# with a sucker rod (see syslogd(8) for more on sucker rods).
view release on metacpan or search on metacpan
script/cloudconvert view on Meta::CPAN
## check usage
pod2usage("missing apikey") unless $opt{apikey};
pod2usage("missing input file") unless @ARGV;
## guess missing options
my ($input, $output) = @ARGV;
if ($input =~ /(.+)\.([a-z0-9]+)$/) {
$opt{from} ||= $2;
if (!defined $output and $opt{to}) {
$output = "$1.".$opt{to};
view release on metacpan or search on metacpan
lib/App/cpan2arch/WritePkgbuild.pm view on Meta::CPAN
next;
}
# Guess license
my @guesses;
{
require Software::LicenseUtils;
Software::LicenseUtils->VERSION('0.104007');
@guesses = Software::LicenseUtils->guess_license_from_meta_key($license);
$self->_pdump( '@guesses', \@guesses, "\n" );
}
my $spdx = $guesses[0]->spdx_expression;
$self->_pdump( '$spdx', \$spdx, "\n" );
if ( !defined $spdx ) {
$_install_license = true;
view release on metacpan or search on metacpan
lib/App/cpanminus/fatscript.pm view on Meta::CPAN
#pod =method load_string
#pod
#pod my $meta = CPAN::Meta->load_string($string, \%options);
#pod
#pod If you don't know if a string contains YAML or JSON, this method will use
#pod L<Parse::CPAN::Meta> to guess. In other respects it is identical to
#pod C<load_file()>.
#pod
#pod =cut
sub load_string {
lib/App/cpanminus/fatscript.pm view on Meta::CPAN
=head2 load_string
my $meta = CPAN::Meta->load_string($string, \%options);
If you don't know if a string contains YAML or JSON, this method will use
L<Parse::CPAN::Meta> to guess. In other respects it is identical to
C<load_file()>.
=head2 save
$meta->save($distmeta_file, \%options);
lib/App/cpanminus/fatscript.pm view on Meta::CPAN
MAPPING section below to learn about those.
=item * strict checking of JSON correctness
There is no guessing, no generating of illegal JSON texts by default,
and only JSON is accepted as input by default (the latter is a security feature).
But when some options are set, loose chcking features are available.
=back
lib/App/cpanminus/fatscript.pm view on Meta::CPAN
=head2 PERL -> JSON
The mapping from Perl to JSON is slightly more difficult, as Perl is a
truly typeless language, so we can only guess which JSON type is meant by
a Perl value.
=over 4
=item hash references
lib/App/cpanminus/fatscript.pm view on Meta::CPAN
=head1 OBJECT METHODS
=head2 C<< name() >>
Returns the name of the package represented by this module. If there
is more than one package, it makes a best guess based on the
filename. If it's a script (i.e. not a *.pm) the package name is
'main'.
=head2 C<< version($package) >>
lib/App/cpanminus/fatscript.pm view on Meta::CPAN
=head2 load_string
my $metadata_structure = Parse::CPAN::Meta->load_string($some_string);
If you don't know whether a string contains YAML or JSON data, this method
will use some heuristics and guess. If it can't tell, it assumes YAML.
=head2 yaml_backend
my $backend = Parse::CPAN::Meta->yaml_backend;
lib/App/cpanminus/fatscript.pm view on Meta::CPAN
$self->environment_vars_string;
}
sub environment_vars_string {
my ($self, $shelltype) = @_;
$shelltype ||= $self->guess_shelltype;
my $extra = $self->extra;
my @envs = (
PATH => $self->bins,
PERL5LIB => $self->libs,
lib/App/cpanminus/fatscript.pm view on Meta::CPAN
}
mkdir $_ for reverse @dirs;
return;
}
sub guess_shelltype {
my $shellbin
= defined $ENV{SHELL}
? ($ENV{SHELL} =~ /([\w.]+)$/)[-1]
: ( $^O eq 'MSWin32' && exists $ENV{'!EXITCODE'} )
? 'bash'
view release on metacpan or search on metacpan
}
sub INTERPOLATE_ENV () { 1 }
sub LITERAL_ENV () { 0 }
sub guess_shelltype {
my $shellbin = 'sh';
if(defined $ENV{'SHELL'}) {
my @shell_bin_path_parts = File::Spec->splitpath($ENV{'SHELL'});
$shellbin = $shell_bin_path_parts[-1];
}
# call itself csh unless it really is. also, default to bourne in the
# pathological situation where a user doesn't have $ENV{SHELL} defined.
# note also that shells with funny names, like zoid, are assumed to be
# bourne.
my $shelltype = $class->guess_shelltype;
while (@envs) {
my ($name, $value) = (shift(@envs), shift(@envs));
$value =~ s/(\\")/\\$1/g;
$out .= $class->${\"build_${shelltype}_env_declaration"}($name, $value);
view release on metacpan or search on metacpan
lib/App/dategrep/Date.pm view on Meta::CPAN
$to -= $to % 60;
my $from = $to - $minutes * 60;
return ( $from, $to );
}
sub guess_format {
my ( $self, $line ) = @_;
for my $format ( @{ $self->{formats} } ) {
my $date = eval { App::dategrep::Strptime::strptime( $line, $format ) };
warn "$@" if $@;
return $format if $date;
lib/App/dategrep/Date.pm view on Meta::CPAN
}
sub to_epoch {
my ( $self, $line, $format, $defaults ) = @_;
$format ||= $self->guess_format($line);
if ( !$format ) {
return ( undef, "No date found in line $line" );
}
view release on metacpan or search on metacpan
bin/module-depakable view on Meta::CPAN
So in other words, this routine checks that a module is PP (pure-perl) I<and> all
of its (direct and indirect) dependencies are PP or core.
To check whether a module is PP/XS, C<Module::XSOrPP> is used and this requires
that the module is installed because C<Module::XSOrPP> guesses by analyzing the
module's source code.
To list all direct and indirect dependencies of a module, C<lcpan> is used, so
that application must be installed and run first to download and index a local
CPAN/CPAN-like repository.
view release on metacpan or search on metacpan
$msg .= "\n" unless $msg =~ /\n$/;
warn "DEBUG: $msg" if $DEBUG;
}
sub _guess_format_from_filename {
my $filename = shift;
# try to detect type from filename
if ($filename =~ /\.(json|js)\z/i) {
return 'json';
last;
} elsif ($filename =~ s/:(json|yaml|perl)\z//) {
$fmt = $1;
last;
} else {
$fmt = _guess_format_from_filename($filename);
last if $fmt;
}
# XXX detect format by reading a few lines from it
last;
} elsif ($filename =~ s/:(json|yaml|perl)\z//) {
$fmt = $1;
last;
} else {
$fmt = _guess_format_from_filename($filename);
last if $fmt;
}
$fmt = $Opts{default_output_format};
}
=item * Convert JSON to YAML
% dt books.json -o books.yaml
Input and output format are guessed from filename extension. Or, you can also
use C<:FORMAT> notation for input, e.g.:
% dt books.dat:json -o books.yml
These formats are currently supported: C<json>, C<yaml>, C<perl>.
Set default output format. Default is C<json>. Can also be C<yaml>, C<perl>,
C<raw>.
=item * --output FILENAME, -o
Add an output. Format will be guessed from .
If not specified, will output all data to STDOUT.
=back
view release on metacpan or search on metacpan
script/_genpw-id view on Meta::CPAN
# my $self = shift;
# $self->{stream} .= join '', @_;
#}
#
## Emit a string value. YAML has many scalar styles. This routine attempts to
## guess the best style for the text.
#sub _emit_str {
# my $self = shift;
# my $type = $_[1] || 0;
#
# # Use heuristics to find the best scalar emission style.
view release on metacpan or search on metacpan
script/_genpw-ind view on Meta::CPAN
# my $self = shift;
# $self->{stream} .= join '', @_;
#}
#
## Emit a string value. YAML has many scalar styles. This routine attempts to
## guess the best style for the text.
#sub _emit_str {
# my $self = shift;
# my $type = $_[1] || 0;
#
# # Use heuristics to find the best scalar emission style.
view release on metacpan or search on metacpan
lib/FlashVideo/Generic.pm view on Meta::CPAN
$param =~ /([^ ]+@{[EXTENSIONS]})/gi,
$param =~ /SWFObject\(["']([^"']+)/) {
debug "Found $file";
my ($actual_url, $filename, $filename_is_reliable) = guess_file($browser, $file, '', $prefs);
if(!$actual_url && $file =~ /\?(.*)/) {
# Maybe we have query params?
debug "Trying query param on $1";
for my $query_param(split /[;&]/, $1) {
my($query_key, $query_value) = split /=/, $query_param;
debug "Found $query_value from $query_key";
($actual_url, $filename, $filename_is_reliable)
= guess_file($browser, $query_value, '', $prefs);
last if $actual_url;
}
}
lib/FlashVideo/Generic.pm view on Meta::CPAN
}
return;
}
sub guess_file {
my($browser, $file, $once, $prefs) = @_;
# Contains lots of URI encoding, so try escaping..
$file = uri_unescape($file) if scalar(() = $file =~ /%[A-F0-9]{2}/gi) > 3;
lib/FlashVideo/Generic.pm view on Meta::CPAN
# It's a video..
debug "Found a video at $uri";
return $uri;
}
# If this looks like HTML we have no hope of guessing right, so
# give up now.
return if $browser->content =~ /<html[^>]*>/i;
if($browser->content =~ m!($video_re)!) {
# Found a video URL
return $1;
} elsif(!defined $once
&& $browser->content =~ m!(http[-:/a-zA-Z0-9%_.?=&]+)!i) {
# Try once more, one level deeper..
return guess_file($browser, $1, 1, $prefs);
} else {
info "Tried $uri, but no video URL found";
}
} elsif($content_type =~ m!application/! && $uri ne $orig_uri) {
# We were redirected, maybe something in the new URL?
lib/FlashVideo/Generic.pm view on Meta::CPAN
my $swf_uri = URI->new_abs($1, $browser->uri);
if($swf_uri) {
my $new_uri = URI->new_abs($file, $swf_uri);
debug "Found SWF: $swf_uri -> $new_uri";
if($new_uri ne $uri) {
return guess_file($browser, $new_uri, 1, $prefs);
}
}
}
}
}
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
else {
print
"*** Dependencies will be installed the next time you type '$make'.\n";
}
# make an educated guess of whether we'll need root permission.
print " (You may need to do that as the 'root' user.)\n"
if eval '$>';
}
print "*** $class configuration finished.\n";
inc/Module/AutoInstall.pm view on Meta::CPAN
or _load('CPANPLUS::Shell::Default')
)
);
}
# make guesses on whether we're under the CPAN installation directory
sub _under_cpan {
require Cwd;
require File::Spec;
my $cwd = File::Spec->canonpath( Cwd::cwd() );
view release on metacpan or search on metacpan
# my $self = shift;
# $self->{stream} .= join '', @_;
#}
#
## Emit a string value. YAML has many scalar styles. This routine attempts to
## guess the best style for the text.
#sub _emit_str {
# my $self = shift;
# my $type = $_[1] || 0;
#
# # Use heuristics to find the best scalar emission style.
view release on metacpan or search on metacpan
t/encoding-rss.t view on Meta::CPAN
<link>https://alexschroeder.ch/</link>
<pubDate>Mon, 13 Jan 2020 23:16:01 +0100</pubDate>
<item>
<title>السّلام عليك</title>
<link>http://hello/wiki?user=Alex&lang=ar</link>
<description><style>some CSS, I guess</style><em>D&D</em> is not bad!<br>You'll like <span class='p-name'>Foo & Bar</span>.</description>
<author><span class='p-author h-card'>Alex Schroeder</span></author>
</item>
</channel>
</rss>
EOT
view release on metacpan or search on metacpan
.claude/rules/karr-rules.md view on Meta::CPAN
launch (same priority as `.claude/CLAUDE.md`). Subagents get their discipline from the skills
force-loaded via `briefing.skills` — this file is for the orchestrating agent.
## Engineering discipline
1. **Think before coding** — State assumptions. When uncertain, ask rather than guess. Present
alternatives when ambiguous. Push back when a simpler approach exists. Stop when confused;
name what's unclear.
2. **Simplicity first** — Minimum code that solves the problem. Nothing speculative. No
abstractions for single-use code.
3. **Surgical changes** — Touch only what you must. Don't "improve" adjacent code, comments, or
view release on metacpan or search on metacpan
lib/App/lcpan/Cmd/doc.pm view on Meta::CPAN
ORDER BY content.size DESC
LIMIT 1", {}, @bind);
last LOOK if $row;
if ($ext eq 'pod') {
# .pod doesn't always declare package so we also try to guess
# from content path
$name =~ s!::!/!g; $name .= ".pod";
@where = ("content.path LIKE ?");
push @where, ("NOT(file.name LIKE '%-Lumped-%')"); # tmp
@bind = ("%$name");
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
if ( @Missing and not( $CheckOnly or $UnderCPAN ) ) {
require Config;
print
"*** Dependencies will be installed the next time you type '$Config::Config{make}'.\n";
# make an educated guess of whether we'll need root permission.
print " (You may need to do that as the 'root' user.)\n"
if eval '$>';
}
print "*** $class configuration finished.\n";
inc/Module/AutoInstall.pm view on Meta::CPAN
or _load('CPANPLUS::Shell::Default')
)
);
}
# make guesses on whether we're under the CPAN installation directory
sub _under_cpan {
require Cwd;
require File::Spec;
my $cwd = File::Spec->canonpath( Cwd::cwd() );
view release on metacpan or search on metacpan
lib/App/loggrep.pm view on Meta::CPAN
return 0 if $start <= $t1;
my $lim = $#$lines;
my ( $s, $e ) = ( [ 0, $t1 ], [ $lim, $t2 ] );
my ( $last, $revcount ) = ( -1, 0 );
{
my $i = _guess( $s, $e, $start );
return $i if $i == $s->[0];
my $rev = $last == $i;
$last = $i;
if ($rev) { # if we find ourselves looping; bail out
$revcount++;
lib/App/loggrep.pm view on Meta::CPAN
redo;
}
}
# estimate the next log line to try
sub _guess {
my ( $s, $e, $start ) = @_;
my $delta = $start - $s->[1];
return $s->[0] unless $delta;
my $diff = $e->[1] - $s->[1];
my $offset = int( ( $e->[0] - $s->[0] ) * $delta / $diff );
view release on metacpan or search on metacpan
Date : 2019-11-19 21:02:51 +0000
fix default watch directories
Morbo doesn't watch the current directory. It watches the 'lib' and
'templates' directories and the Mojolicious app script. We guess at
the app script if we can, and pick the 'lib' and 'templates'
directories.
Watching the current directory by default also ensures that anything
written to the `MOJO_HOME` will cause a restart. Since it's common
view release on metacpan or search on metacpan
1.06
- guess MIME type based on file extension (that is, .txt files are no
longer served as text/gemini, you need to use .gmi, or some other
file extension File::MimeInfo doesn't know about)
- new dependency: File::MimeInfo
view release on metacpan or search on metacpan
script/_metasyn view on Meta::CPAN
# my $self = shift;
# $self->{stream} .= join '', @_;
#}
#
## Emit a string value. YAML has many scalar styles. This routine attempts to
## guess the best style for the text.
#sub _emit_str {
# my $self = shift;
# my $type = $_[1] || 0;
#
# # Use heuristics to find the best scalar emission style.