view release on metacpan or  search on metacpan

lib/App/Basis/Queue.pm  view on Meta::CPAN

    return if ( !$self->{debug} ) ;

    my $msg = shift ;
    $msg =~ s/^/    /gsm ;

    say STDERR $msg ;
}

# -----------------------------------------------------------------------------
sub _build_sql_stmt
{

lib/App/Basis/Queue.pm  view on Meta::CPAN

=back

B<Example usage>

    my $count = $queue->size( queue => 'queue_name') ;
    say "there are $count items in the queue" ;

    # size can manage wildcards
    $queue->size( queue => '/celestial/*') ;

=cut

lib/App/Basis/Queue.pm  view on Meta::CPAN

=back

B<Example usage>

    my $count = $queue->queue_size( queue => 'queue_name') ;
    say "there are $count unprocessed items in the queue" ;

    # queue size can manage wildcards
    $queue->queue_size( queue => '/celestial/*') ;

=cut

lib/App/Basis/Queue.pm  view on Meta::CPAN

B<Example usage>

    my $qlist = $queue->list_queues() ;
    foreach my $q (@$qlist) {
        say $q ;
    }

=cut

sub list_queues

lib/App/Basis/Queue.pm  view on Meta::CPAN

avg_elapsed, max_elapsed, min_elapsed

B<Example usage>

    my $stats = $queue->stats( queue => 'queue_name') ;
    say "processed $stats->{processed}, failures $stats->{failure}, unprocessed $stats->{unprocessed}" ;

    # for all matching wildcard queues
    my $all_stats = $queue->stats( queue => '/celestial/*') ;

=cut

lib/App/Basis/Queue.pm  view on Meta::CPAN

        # we are only interested in 10 messages
        if( ++$counter > 10) {
            $q->unsubscribe( queue => $queue) ;
        } else {
            say Data::Dumper( $data) ;
        }
    }

    my $queue = App::Basis::Queue->new( dbh => $dbh) ;
    $queue->subscribe( queue => '/logs/*', callback => \&handler) ;

lib/App/Basis/Queue.pm  view on Meta::CPAN

    my $before = $queue->stats( queue => 'queue_name', before => '2015-11-24') ;
    $queue->purge_tasks( queue => 'queue_name') ;
    my $after = $queue->stats( queue  => 'queue_name') ;

    say "removed " .( $before->{total_records} - $after->{total_records}) ;

=cut

sub purge_tasks
{

lib/App/Basis/Queue.pm  view on Meta::CPAN

B<Example usage>

    my $del = $queue->purge_chatter( queue => 'queue_name', before => '2015-11-24') ;

    say "removed $del messages" ;

=cut

sub purge_chatter
{

lib/App/Basis/Queue.pm  view on Meta::CPAN

    $queue->remove_queue( queue => 'queue_name') ;
    my $after = $queue->list_queues() ;
    # convert list into a hash for easier checking
    my %a = map { $_ => 1} @after ;
    say "queue removed" if( !$q->{queue_name}) ;

=cut

sub remove_queue
{

lib/App/Basis/Queue.pm  view on Meta::CPAN

    my $before = $queue->stats( queue => 'queue_name') ;
    $queue->reset_failures( queue => 'queue_name') ;
    my $after = $queue->stats( queue => 'queue_name') ;

    say "reset " .( $after->{unprocessed} - $before->{unprocessed}) ;

=cut

sub reset_failures
{

lib/App/Basis/Queue.pm  view on Meta::CPAN

B<Example usage>

    $queue->remove_failues( queue => 'queue_name') ;
    my $stats = $queue->stats( queue => 'queue_name') ;
    say "failues left " .( $stats->{failures}) ;

=cut

sub remove_failures
{

 view release on metacpan or  search on metacpan

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

    use Data::Dumper;

    my $parser = App::BatParser->new;
    my $bat_string = Path::Tiny::path('t/cmd/simple.cmd')->slurp;

    say Dumper($parser->parse($bat_string));

=head1 METHODS

=head2 grammar

 view release on metacpan or  search on metacpan

colsummary  view on Meta::CPAN

  $SIG{INT} = sub { select *STDERR ; & ColStat ; select *STDOUT ; return } ; 
  sleep 2 ; 
  return ;
} ;
$SIG{ INT } = ${ INT1 } ;
$SIG{ ALRM } = sub { say STDERR GREEN + (d3 $rl) . " lines read. " , scalar localtime ; alarm $sec } ; 
alarm $sec ; 

eachFile $_ for @ARGV ;
exit 0 ;

colsummary  view on Meta::CPAN

  $rl = d3 ($rl // 0) ; # read lines
  my $procsec = tv_interval ${ dt_start } ;
  my $out = "$rl line(s) read; "; 
  $out .= "$nc cells are not counted; " if $nc ;
  $out .= sprintf '%0.6f seconds (colsummary)', $procsec ; # たまにマイクロ秒単位の$procsecが15桁くらいで表示されるのでsprintf。
  say STDERR BOLD DARK ITALIC CYAN $out ;
}

### 各列の値の分布を取り出す
sub ColFreq ( $$ ) { # 第１変数はファイルハンドル 第２変数は参照
  #my %zstr ; # 除外された文字列の出現頻度。(点検用でもある。)     #my $intflg ; #$SIG{INT} = sub { $intflg = 1 } ; 

colsummary  view on Meta::CPAN

  push @P , BRIGHT_YELLOW $p[3] ;## (4) 列の名前(列名)を表示
  push @P , BRIGHT_WHITE $p[4] ; ## (5) 値の最大と最小を取り出す。
  push @P , $p[5] ;## (6)  具体的な値の表示 (出現度数の多い順に $o{g} 個 ) 
  push @P , BRIGHT_GREEN $p[6] . GREEN $p[7] ;## ## (7) 最頻度数の分布## (7) 中点(なかてん)の処理 (7) テール度数の分布
  push @P , BRIGHT_BLUE $p[8] ;  ## (8) 値の文字列長の範囲の表示
  say join "\t" , @P ;
}

# 平均値を計算する処理をする。
sub aveft ( $$ ) {
  my ($rHash,$rKeys) = @_ ;

 view release on metacpan or  search on metacpan

README.md  view on Meta::CPAN

### 列をいろいろ操作(csel)

```
cpanm App::csel
# ↑ コマンド csel をインストール。
perl -E'say join"\t",1..12' | tee c12.tsv
# 1   2   3   4   5   6   7   8   9   10  11  12  
awk '{print$3,$4,$5,$6,$7}' c12.tsv # AWKの例
# 3 4 5 6 7
csel -p 3..7 c12.tsv # cselはAWKより簡単
# 3   4   5   6   7

 view release on metacpan or  search on metacpan

README.md  view on Meta::CPAN

### 列をいろいろ操作(csel)

```
cpanm App::csel
# ↑ コマンド csel をインストール。
perl -E'say join"\t",1..12' | tee c12.tsv
# 1   2   3   4   5   6   7   8   9   10  11  12  
awk '{print$3,$4,$5,$6,$7}' c12.tsv # AWKの例
# 3 4 5 6 7
csel -p 3..7 c12.tsv # cselはAWKより簡単
# 3   4   5   6   7

 view release on metacpan or  search on metacpan

scripts/backcolor  view on Meta::CPAN

			my $d = max 0, min 5, int $n / $o{d} ; 
			my $c = "on_rgb00$d" ;
			$_ = color ($c) . $_ . color ('reset') ; 
		}
	}
	say join "\t", @F ; 
}


=encoding utf8 

 view release on metacpan or  search on metacpan

bin/paper-wallet  view on Meta::CPAN

sub echo
{
	my ($message) = @_;

	say $message if $interactive;
	return;
}

sub prompt
{

 view release on metacpan or  search on metacpan

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

    }

    my $bf = Algorithm::BloomFilter->deserialize($bf_str);

    for (@{ $args{items} }) {
        say $bf->test($_) ? 1:0;
    }

    [200];
}

 view release on metacpan or  search on metacpan

lib/App/BlurFill/CLI.pm  view on Meta::CPAN

        file   => $in,
        %opts,
    );

    my $outfile = $blur->process;
    say "Wrote $outfile";
  }
}

=head1 AUTHOR

 view release on metacpan or  search on metacpan

lib/App/BoolFindGrep/CLI.pm  view on Meta::CPAN

              \sline\s
              (?<line>\d+)\.\s*\z
             }msx
            )
        {
            say STDERR sprintf q(%s: %s), $PROGRAM_NAME,
                $LAST_PAREN_MATCH{msg};
        }
        return;
    } ## end if ($EVAL_ERROR)

lib/App/BoolFindGrep/CLI.pm  view on Meta::CPAN

sub _msg {
    my $self = shift;
    my $msg  = shift;

    say STDERR sprintf q(%s: %s), $PROGRAM_NAME, $msg;
    say STDERR sprintf q(Try '%s --help' for more information.),
        $PROGRAM_NAME;

    return 1;
}

 view release on metacpan or  search on metacpan

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

    summary => "Check whether Brave is running",
    description => <<'_',

Brave is defined as running if there are some Brave processes that are *not*
in 'stop' state. In other words, if Brave has been started but is currently
paused, we do not say that it's running. If you want to check if Brave process
exists, you can use `ps_brave`.

_
    args => {
        %App::BrowserUtils::args_common,

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

Check whether Brave is running.

Brave is defined as running if there are some Brave processes that are I<not>
in 'stop' state. In other words, if Brave has been started but is currently
paused, we do not say that it's running. If you want to check if Brave process
exists, you can use C<ps_brave>.

This function is not exported.

Arguments ('*' denotes required arguments):

 view release on metacpan or  search on metacpan

bin/bulkmail  view on Meta::CPAN

Be more verbose

=item B<--quiet>

Don't say anything implicitely

=item B<--recipients <file>>

File containing list of recipients. Can be formatted as CSV, JSON, YAML or as
an simple list of email addresses. For CSV files the first line defined a list

 view release on metacpan or  search on metacpan

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

	:~$ perl -MApp::CCSV -ne 'csay @f[1,4,7,22]' < csv.csv > csv2.csv

	# Easy checking if there are field values that contain the quote char -
	# means, checking if you can get by with normal autosplit or if you really have
	# to treat your file as CSV (this example works from perl 5.10 onwards):
	:~$ perl -MApp::CCSV -F/\;/ -lanE 'say if !(@f ~~ @F)' < csv.csv


=head1 SEE ALSO

L<Text::CSV_XS>, L<Config::General>, L<perlrun>

 view release on metacpan or  search on metacpan

lib/App/CLI/Extension.pm  view on Meta::CPAN

  use base qw(App::CLI::Command);
     
  sub run {
  
      my($self, @args) = @_;
      say "my script name is " . $self->argv0;
  }
  
  1;

  # execute

lib/App/CLI/Extension.pm  view on Meta::CPAN

  use base qw(App::CLI::Command);
  
  sub run {
  
      my($self, @args) = @_;
      say "my script full name is " . $self->full_argv0;
  }
  
  1;
  
  # execute

lib/App/CLI/Extension.pm  view on Meta::CPAN

  use base qw(App::CLI::Command);
  
  sub run {
  
      my($self, @args) = @_;
      say "my script cmdline is [" . $self->cmdline . "]";
  }
  
  1;
  
  # execute

lib/App/CLI/Extension.pm  view on Meta::CPAN

  use base qw(App::CLI::Command);
  
  sub run {
  
      my($self, @args) = @_;
      say "my script original argv is [" join(", ", @{$self->orig_argv}) . "]";
  }
  
  1;
  
  # execute

lib/App/CLI/Extension.pm  view on Meta::CPAN

   
  sub run {
  
      my($self, @args) = @_;
      $self->stash->{name} = "kurt";
      say "stash value: " . $self->stash->{name};
  }
  
  1;

=head2 new_callback

lib/App/CLI/Extension.pm  view on Meta::CPAN

install callback

Example:

  $self->add_callback("some_phase", sub { my $self = shift; say "some_phase method No.1" });
  $self->add_callback("some_phase", sub { my $self = shift; say "some_phase method No.1" });
  $self->add_callback("any_phase", sub {
                                     my($self, @args) = @_;
                                     say "any_phase args: @args";
                                  });

=cut

=head2 exec_callback

 view release on metacpan or  search on metacpan

inc/Test/Builder.pm  view on Meta::CPAN

        if( $arg ) {
            return $self->expected_tests($arg);
        }
        elsif( !defined $arg ) {
            die "Got an undefined number of tests.  Looks like you tried to ".
                "say how many tests you plan to run but made a mistake.\n";
        }
        elsif( !$arg ) {
            die "You said to run 0 tests!  You've got to run something.\n";
        }
    }

 view release on metacpan or  search on metacpan

inc/Test/Builder.pm  view on Meta::CPAN

        if( $arg ) {
            return $self->expected_tests($arg);
        }
        elsif( !defined $arg ) {
            die "Got an undefined number of tests.  Looks like you tried to ".
                "say how many tests you plan to run but made a mistake.\n";
        }
        elsif( !$arg ) {
            die "You said to run 0 tests!  You've got to run something.\n";
        }
    }

 view release on metacpan or  search on metacpan

inc/Test/Builder.pm  view on Meta::CPAN

        if( $arg ) {
            return $self->expected_tests($arg);
        }
        elsif( !defined $arg ) {
            die "Got an undefined number of tests.  Looks like you tried to ".
                "say how many tests you plan to run but made a mistake.\n";
        }
        elsif( !$arg ) {
            die "You said to run 0 tests!  You've got to run something.\n";
        }
    }

 view release on metacpan or  search on metacpan

inc/Test/Builder.pm  view on Meta::CPAN

        if( $arg ) {
            return $self->expected_tests($arg);
        }
        elsif( !defined $arg ) {
            die "Got an undefined number of tests.  Looks like you tried to ".
                "say how many tests you plan to run but made a mistake.\n";
        }
        elsif( !$arg ) {
            die "You said to run 0 tests!  You've got to run something.\n";
        }
    }

 view release on metacpan or  search on metacpan

inc/Test/Builder.pm  view on Meta::CPAN

        if( $arg ) {
            return $self->expected_tests($arg);
        }
        elsif( !defined $arg ) {
            die "Got an undefined number of tests.  Looks like you tried to ".
                "say how many tests you plan to run but made a mistake.\n";
        }
        elsif( !$arg ) {
            die "You said to run 0 tests!  You've got to run something.\n";
        }
    }

 view release on metacpan or  search on metacpan

inc/Test/Builder.pm  view on Meta::CPAN

        if( $arg ) {
            return $self->expected_tests($arg);
        }
        elsif( !defined $arg ) {
            die "Got an undefined number of tests.  Looks like you tried to ".
                "say how many tests you plan to run but made a mistake.\n";
        }
        elsif( !$arg ) {
            die "You said to run 0 tests!  You've got to run something.\n";
        }
    }

 view release on metacpan or  search on metacpan

bin/visitcpan  view on Meta::CPAN

   # count number of distributiosn in the minicpan
   $ visitcpan | wc -l
 
   # get a listing of all distributions using Build.PL
   $ visitcpan -q -a dist -o listing.txt -e 'say shift if -f "Build.PL"'
 
   # run a program against each distribution
   $ visitcpan -q -- ack -a 'use version;'

=head1 SEE ALSO

 view release on metacpan or  search on metacpan

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

sub DEBUG { $ENV{SBOM_DEBUG} || 0 }

sub cli_error {
    my ($error, $code) = @_;
    $error =~ s/ at .* line \d+.*//;
    say STDERR "ERROR: $error";
    return $code || 1;
}

sub run {

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

    if (defined $options{v}) {
        return show_version();
    }

    if ($options{'list-spdx-licenses'}) {
        say $_ for (sort @{SBOM::CycloneDX::Enum->SPDX_LICENSES});
        return 0;
    }

    unless ($options{distribution} || $options{'project-meta'} || $options{'project-directory'}) {
        pod2usage(-exitstatus => 0, -verbose => 0);

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

    $bom->metadata->timestamp(time);
    $bom->metadata->tools->push(cyclonedx_tool());

    my $output_file = $options{output} // 'bom.json';

    say STDERR "Save SBOM to $output_file";

    open my $fh, '>', $output_file or Carp::croak "Failed to open file: $!";
    say $fh $bom->to_string;
    close $fh;

    if ($options{validate}) {
        my @errors = $bom->validate;
        say STDERR $_ foreach (@errors);
    }

    if (defined $options{'server-url'} && defined $options{'api-key'}) {
        submit_bom(bom => $bom, options => \%options);
    }

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

sub show_version {

    (my $progname = $0) =~ s/.*\///;

    say <<"VERSION";
$progname version $VERSION

Copyright 2025-2026, Giuseppe Di Terlizzi <gdt\@cpan.org>

This program is part of the "App-CPAN-SBOM" distribution and is free software;

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

    my $bom     = $params{bom};
    my $options = $params{options} || {};

    my @META_FILES = (qw[META.json META.yml MYMETA.json MYMETA.yml]);

    say STDERR 'Generate SBOM';

    my $project_type        = $options->{'project-type'} || 'library';
    my $project_directory   = File::Spec->rel2abs($options->{'project-directory'});
    my $project_meta        = $options->{'project-meta'}    || $options->{'meta'};
    my $project_name        = $options->{'project-name'}    || basename($project_directory);

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

    my $distribution = $params{distribution};
    my $version      = $params{version};
    my $bom          = $params{bom};
    my $options      = $params{options} || {};

    say STDERR "Generate SBOM for $distribution\@$version";

    my $mcpan        = MetaCPAN::Client->new;
    my $release_data = $mcpan->release({all => [{distribution => $distribution}, {version => $version}]});

    my $dist_data = $release_data->next;

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

    if ($module) {

        $module = 'perl' if ($module eq 'Perl');

        DEBUG
            and say STDERR sprintf '-- %s[%d] Collect module %s@%s info (parent component %s)',
            ("    " x ($depth - 1)), $depth, $module, $version, $parent_component->bom_ref;

        my $module_data = $mcpan->module($module);

        unless ($module_data) {

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

    });

    my $dist_data = $release_data->next;

    DEBUG
        and say STDERR sprintf '-- %s[%d] Collect distribution %s@%s info (parent component %s)',
        ("    " x ($depth - 1)), $depth, $distribution, $version, $parent_component->bom_ref;

    unless ($dist_data) {
        Carp::carp("Unable to find release ($distribution\@$version) in Meta::CPAN");
        return;

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

    my $ua = HTTP::Tiny->new(
        verify_SSL      => $verify_ssl,
        default_headers => {'Content-Type' => 'application/json', 'X-Api-Key' => $options->{'api-key'}}
    );

    say STDERR "Upload BOM in OSWASP Dependency Track ($server_url)";

    my $response = $ua->put($server_url, {content => encode_json($bom_payload)});

    DEBUG and say STDERR "-- Response <-- " . Dumper($response);

    unless ($response->{success}) {
        return cli_error(sprintf(
            'Failed to upload BOM file to OWASP Dependency Track: (%s) %s - %s',
            $response->{status}, $response->{reason}, $response->{content}

 view release on metacpan or  search on metacpan

lib/App/CPAN2Pkg/Worker.pm  view on Meta::CPAN

    event check_local_availability => sub {
        my $self    = shift;
        my $modname = $self->module->name;

        my $cmd = qq{ perl -M$modname -E 'say "$modname loaded successfully";' };
        $K->post( main => log_step => $modname => "Checking if module is installed" );
        $self->run_command( $cmd => "_check_local_availability_result" );
    };

    #

lib/App/CPAN2Pkg/Worker.pm  view on Meta::CPAN

        $K->post( main => log_err => $self->module->name => $line );
    };

    event _child_close => sub {
        my ($self, $wid) = @_[OBJECT, ARG0];
        #say "child closed all pipes";
    };

    event _child_signal => sub {
        my ($self, $pid, $status) = @_[OBJECT, ARG1, ARG2];
        $K->post( main => log_out => $self->module->name => "" );

 view release on metacpan or  search on metacpan

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

    use App::CPANCoverBadge;

    my $badger = App::CPANCoverBadge->new;
    my $badge  = $badger->badge( 'App-CPANCoverBadge-0.01' );
    
    say $badge;

=head1 ATTRIBUTES

=over 4

 view release on metacpan or  search on metacpan

bin/mksite  view on Meta::CPAN

    $ mksite My::Lovely::Module

=head1 DESCRIPTION

This program will automatically generate a web site for a CPAN module
(actually, it's more accurate to say a CPAN distribution). It gets the
information used to create the site from two sources:

=over 4

=item * It uses the MetaCPAN API to get data about the distribution.

 view release on metacpan or  search on metacpan

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

    foreach my $date ( sort keys %{$certs} ) {
        foreach my $certuser ( @{ $certs->{$date} } ) {
            my $fullname = $self->_resolve_name( $certuser->{familyname},
                $certuser->{givenname} );

            #say "Certificate found for $fullname";
            $certificate_count++;

# TODO Check if certificate date is already filled in and of is it keep the most recent one.
# Might not be required because we sort the date keys.
            if ( defined $self->{_employees}->{$fullname} ) {

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

            }
        }
    }

    say "$certificate_count certificates found";

    my $training_count = 0;
    my $training       = $self->{_training};
    foreach my $traininguser ( @{$training} ) {
        my $fullname = $self->_resolve_name( $traininguser->{familyname},
            $traininguser->{givenname} );

        #say "Training found for $fullname";
        # TODO deduplicate this code with a local function, see above
        if ( defined $self->{_employees}->{$fullname} ) {

            # Fill in training if there is no certificate yet, otherwise notify!
            if ( !defined $self->{_employees}->{$fullname}->{cert} ) {

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

            push( @{ $self->{_not_in_hr}->{training} }, $fullname );
            $training_count++;
        }
    }

    say "$training_count people are in training";

    # Check people who are in training and that have a certificate
    # now run the stats, for every dienst separately report
    my $stats;
    foreach my $employee ( keys %{$self->{_employees}} ) {

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

    }

    #print Dumper($stats);

    # Display the results
    say "Dienst;Certificaat;Training;Niet gestart;Theorie";

    foreach my $dienst ( sort keys %{$stats} ) {
        next if ( $dienst eq 'employee_count' );

        if ( !defined $stats->{$dienst}->{certified}->{count} ) {

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

            $stats->{$dienst}->{not_started}->{count} = 0;
        }
        if ( !defined $stats->{$dienst}->{course}->{count} ) {
            $stats->{$dienst}->{course}->{count} = 0;
        }
        say "$dienst;"
          . $stats->{$dienst}->{certified}->{count} . ";"
          . $stats->{$dienst}->{training}->{count} . ";"
          . $stats->{$dienst}->{not_started}->{count} . ";"
          . $stats->{$dienst}->{course}->{count};

    }

    if ( defined $self->{_not_in_hr}->{cert} ) {
        say "";
        say "Not found in the HR database while parsing certificates: "
          . scalar( @{ $self->{_not_in_hr}->{cert} } );
        foreach ( @{ $self->{_not_in_hr}->{cert} } ) {
            say;
        }
    }

    if ( defined $self->{_not_in_hr}->{training} ) {
        say "Not found in the HR database while parsing in training: "
          . scalar( @{ $self->{_not_in_hr}->{training} } );
        foreach ( @{ $self->{_not_in_hr}->{training} } ) {
            say;
        }
    }

    if ( defined $self->{_not_in_hr}->{theory} ) {
        say "Not found in the HR database while parsing theory: "
          . scalar( @{ $self->{_not_in_hr}->{theory} } );
        foreach ( @{ $self->{_not_in_hr}->{theory} } ) {
            say;
        }
    }

    #say "";
    #say "Resolved names";
    #print Dumper($self->{_resolve});
}

# Parse the employee database to extract the names and the group they are in
sub _parse_employees {

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

            }
        }
    }

    # Report no match found
    #say "No match in employee database for '$name'";
    $self->{_resolve}->{nomatch} += 1;
    return $name;

}

# Log resolved names so that they can be used for later reference
sub _fixlog {
    my ( $self, $type, $original, $fixed ) = @_;

    #say "$type match for '$original', replaced by '$fixed'";
    $self->{_resolve}->{$type} += 1;
    push(
        @{ $self->{_resolve_list} },
        { $original => { fixed => $fixed, type => $type } }
    );

 view release on metacpan or  search on metacpan

bin/csv  view on Meta::CPAN

=item B<--to_tsv>, B<--to-tsv>

Use tabs instead of commas as the delimiter. When B<csv> has the input or
output filenames available, this is inferred when they end with C<.tsv>.
To disable this dwimmery, you may say C<--to_tsv=0> and C<--from_tsv=0>.

=back

=head1 SEE ALSO

 view release on metacpan or  search on metacpan

bin/csv2latextable  view on Meta::CPAN

);

usage() if $help;

if ( !$opts{csv} || !$opts{latex} ) {
    say 'Need csv and latex parameters!';
    usage();
}

if ( !-f $opts{csv} ) {
    say "file $opts{csv} does not exist";
    usage();
}

for my $key ( qw/csv_param latex_param/ ) {
    delete $opts{$key} if !defined $opts{$key};

 view release on metacpan or  search on metacpan

lib/App/CSVUtils/csv_lookup_fields.pm  view on Meta::CPAN

                my $val = defined $field_idx ? $row->[$field_idx] : "";
                $val = lc $val if $ci;
                $val;
            } 0..$#{ $r->{lookup_fields} };

            #say "D:looking up '$key' ...";
            if (defined(my $row_idx = $lookup_table{$key})) {
                #say "  D:found";
                my $row_filled;
                my $source_row = $r->{source_data_rows}[$row_idx];
                for my $field (keys %{$r->{fill_fields}}) {
                    my $target_field_idx = $r->{target_fields_idx}{$field};
                    next unless defined $target_field_idx;

 view release on metacpan or  search on metacpan

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

                        my ($type, $name) = $entry =~ /\A(func|meth)::?(.+)\z/ or
                            return [400, "For action print_func_or_meth, ".
                                    "specify func:FUNCNAME or meth:METHNAME"];
                        eval {
                            if ($type eq 'func') {
                                #use DD; say "func: $name(", DD::dump($node_res), ")";
                                $node_res = &{$name}($node_res);
                            } else {
                                #use DD; say "meth: $name on ", DD::dump($node_res);
                                $node_res = $node_res->$name;
                            }
                        };
                        if ($@) {
                            #warn $@;