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

bin/yg  view on Meta::CPAN

=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

Changes  view on Meta::CPAN

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

bin/cloc  view on Meta::CPAN

                    aclocal.m4
                    announce-gen
                    autogen.sh
                    bootstrap
                    compile
                    config.guess
                    config.h.in
                    config.rpath
                    config.status
                    config.sub
                    configure

bin/cloc  view on Meta::CPAN

# 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/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

bin/cpant  view on Meta::CPAN

  }
  
  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];
    }

bin/cpant  view on Meta::CPAN

    # 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

script/dt  view on Meta::CPAN

    $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';

script/dt  view on Meta::CPAN

            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

script/dt  view on Meta::CPAN

            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};
    }

script/dt  view on Meta::CPAN

=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>.

script/dt  view on Meta::CPAN

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

script/_hr  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

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&amp;lang=ar</link>
         <description>&lt;style&gt;some CSS, I guess&lt;/style&gt;&lt;em&gt;D&amp;D&lt;/em&gt; is not bad!&lt;br&gt;You'll like &lt;span class='p-name'&gt;Foo &amp; Bar&lt;/span&gt;.</description>
         <author>&lt;span class='p-author h-card'&gt;Alex Schroeder&lt;/span&gt;</author>
      </item>
   </channel>
</rss>
EOT

 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

CHANGES  view on Meta::CPAN

  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

Changes  view on Meta::CPAN

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.

 view release on metacpan or  search on metacpan

mimi.fatpack  view on Meta::CPAN

  
  	] .join("\n",'',@post_call_frag,'').q[
  
  	return (wantarray) ? @ret : $ret[0];
        }
      ];no strict qw(refs);my$code_ref=eval qq{#line 1 "DBI::PurePerl $method"\n$method_code};warn "$@\n$method_code\n" if $@;die "$@\n$method_code\n" if $@;*$method=$code_ref;if (0 && $method =~ /\b(connect|FETCH)\b/){my$l=0;warn "*$method code:\n"....
DBI_PUREPERL

$fatpacked{"DBI/SQL/Nano.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'DBI_SQL_NANO';
  package DBI::SQL::Nano;use strict;use warnings;use vars qw($VERSION $versions);use Carp qw(croak);require DBI;BEGIN {$VERSION="0.03";$versions->{nano_version}=$VERSION;if ($ENV{DBI_SQL_NANO}||!eval {require SQL::Statement;$SQL::Statement::VERSION g...
DBI_SQL_NANO

mimi.fatpack  view on Meta::CPAN

$fatpacked{"Module/Build.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'MODULE_BUILD';
  package Module::Build;use if $] >= 5.019,'deprecate';use 5.006;use strict;use warnings;use File::Spec ();use File::Path ();use File::Basename ();use Perl::OSType ();use Module::Build::Base;our@ISA=qw(Module::Build::Base);our$VERSION='0.03';$VERSION...
MODULE_BUILD

$fatpacked{"Module/Build/Base.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'MODULE_BUILD_BASE';
  package Module::Build::Base;use 5.006;use strict;use warnings;our$VERSION='0.03';$VERSION=eval$VERSION;use Carp;use Cwd ();use File::Copy ();use File::Find ();use File::Path ();use File::Basename ();use File::Spec 0.82 ();use File::Compare ();use M...
  
  ERRORS/WARNINGS FOUND IN PREREQUISITES.  You may wish to install the versions
  of the modules indicated above before proceeding with this installation
  
  EOF

 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

script/orgsel  view on Meta::CPAN

 ** agus putra
 ** susan muliawati
 ** susi
 ** susi (ron's friend)                                                  :vet:
 - log ::
   + [2021-04-03] met her again (the 3rd time i guess?) at ron's birthday party.
     she's married now.
   + [2019-01-02] entry

Now for some selecting examples on F<addressbook.org>:

 view release on metacpan or  search on metacpan

lib/App/p5stack.pm  view on Meta::CPAN

  $self->{skip_install} = 1;
  $self->{p5stack_root} = catfile($ENV{HOME},'.p5stack');
  $self->{perls_root} = catfile($ENV{HOME},'.p5stack','perls');
  $self->{perl_version} = '5.20.3';

  # guess stuff from context
  $self->{deps} = 'cpanfile' if -e 'cpanfile';

  # read config from file if available
  my $file;
  -e 'p5stack.yml' and $file = 'p5stack.yml';

 view release on metacpan or  search on metacpan

bin/part.pl  view on Meta::CPAN

=over 4

=item B<--out> - set the output template

If the output template is not given it is guessed from
the name of the first input file or set to C<part-%s.txt>.
The C<%s> will be replaced by the column value.

=item B<--column> - set the column to part on

bin/part.pl  view on Meta::CPAN

    exit 0;
};
pod2usage("$0: No files given.")  if ((@ARGV == 0) && (-t STDIN));

if (! defined $tmpl) {
    # Let's hope we can guess from the first filename
    my $placeholder = '-%s' x @col;
    ($tmpl = $ARGV[0] || 'part.txt') =~ s/\.(\w+)$/$placeholder.$1/;
};

if (! defined $sep) {