#!/usr/local/bin/perl

package cpanfm;
use base qw(Term::Shell);

my $obj = cpanfm->new();
$obj->cmdloop;

use strict;
use warnings;
use CPAN;
use CPANPLUS;
use Cwd;
use FindBin qw( $Bin );
use lib "$Bin/../lib";
use Find::Lib libs => [ 'lib', '../lib', 'devlib' ];
use ExtUtils::MakeMaker qw(prompt);
use IPC::System::Simple qw(capture);
use Term::ReadLine;

use version 0.77; our $VERSION = version->declare("v0.0.1");

sub prompt_str {
    my $cwd = cwd;
    $cwd =~ s[^\Q$ENV{HOME}\E][~];
    "cpanfm> "
}    

sub run_help {

 print 
   
   "z\n", 
   "123\n",
   "a\n",
   "acme_kwalitee\n",
   "builtin_vars\n",
   "c\n",
   "cat\n",
   "checkenv\n",
   "con_name\n",
   "concise\n",
   "cover\n",
   "cpan\n",
   "cpanp\n",
   "cpanfm_info\n",
   "critic\n",
   "d\n",
   "deparse\n",
   "details\n",
   "diff\n",
   "du\n",
   "dump_sizes\n",
   "fathom\n",
   "fetch\n",
   "file_size\n",
   "finddeps\n",
   "find_exe\n",
   "find_lib\n",
   "func_list\n",
   "git\n",
   "id\n",
   "infometa\n",
   "inject\n",
   "is_core\n",
   "kwalitee\n",
   "lex\n",
   "license\n",
   "lint\n",
   "listm\n",
   "look\n",
   "ls\n",
   "m\n",
   "minicpan\n",
   "mini_inject\n",
   "minismokebox\n",
   "mod_info\n",
   "modebug\n",
   "monk\n",
   "namespace\n",
   "nytprof\n",
   "parse_backpan\n",
   "parse_cpan\n",
   "parse_mod\n",
   "parse_modlist\n",
   "parse_ratings\n",
   "pause\n",
   "perldoc\n",
   "perldoc_f\n",
   "perldoc_m\n",
   "perldoc_q\n",
   "perldoc_perllocal\n",
   "perlmod\n",
   "pler\n",
   "pmcv\n",
   "pmpath\n",
   "prereq\n",
   "probe\n",
   "proctab\n",
   "readme\n",
   "recent\n",
   "reports\n",
   "runprove\n",
   "score\n",
   "search\n",
   "sysinfo\n",
   "systrace\n",
   "terse_size\n",
   "test\n",
   "tracedeps\n",
   "up\n",
   "vers_mod\n",
   "versys\n",
   "wc\n",
   "whereis\n",
   "xcopy\n",
   "xref\n";
}

sub run_cpanfm_info {

print        "\nModules, Perl, OS info:\n",

"\ncpanfm was built using these modules:\n",

"  strict 1.03\n",
"  warnings 1.05\n",
"  Term::Shell 0.02\n",
"  App::Rad 1.04\n", 
"  Cwd 3.3\n", 
"  CPAN 1.9402\n",
"  CPANPLUS 0.88\n", 
"  lib 0.5565\n",
"  ExtUtils::MakeMaker 6.54\n", 
"  IPC::System::Simple 1.18\n", 
"  Getopt::Long 2.38\n",
"  Pod::Usage 1.36\n", 
"  CPAN::FindDependencies 2.32\n",
"  Module::Info 0.31\n", 
"  Yahoo::Search 1.10.13\n", 
"  Module::Release 2.05\n", 
"  CPAN::Mini::Visit 0.11\n",
"  CPAN::Mini 0.576\n",
"  Parse::BACKPAN::Packages 0.35\n",
"  File::Size 0.06\n",
"  Test::Run::CmdLine 0.0120\n",
"  Module::CoreList 2.18\n", 
"  Parse::CPAN::Modlist 0.9\n",
"  Module::Versions 0.02\n",
"  Parse::CPAN::Ratings 0.33\n",
"  Acme::CPANAuthors::Utils::Kwalitee 0.09\n",
"  WWW::PAUSE::RecentUploads 0.03\n", 
"  Perl::Critic 1.103\n", 
"  CPAN::Dependency 0.15\n", 
"  Devel::Size 0.71\n", 
"  Data::Dumper 2.125\n", 
"  Data::Dumper::Perltidy 0.01\n", 
"  Devel::Leak 0.03\n", 
"  B::PerlReq 0.70\n", 
"  CPAN::PackageDetails 0.20\n", 
"  File::Spec 3.3\n", 
"  Module::Collection 0.02\n",
"  Smart::Comments 1.0.3\n", 
"  App::SmokeBox::Mini 0.18\n",
"  FindBin 1.47\n",
"  Test::Smoke::SysInfo 0.042\n",
"  Module::License::Report 0.02\n", 
"  Proc::ProcessTable 0.45\n", 
"  WWW::CPAN 0.011\n", 
"  Probe::Perl 0.01\n", 
"  Text::Diff 1.37\n", 
"  Text::Diff::Table 1.37\n", 
"  Devel::TraceDeps 0.0.3\n",
"  Term::ReadLine 1.02\n",
"  File::Fetch 0.02\n",
"  App::CPAN::Fast 0.03\n", 
"  CPANPLUS::Module 0\n",
"  Text::Balanced 1.95\n", 
"  Net::FTP 2.77\n",
"  XML::RSS::Headline::UsePerlJournals 2.32\n",
"  LWP::Simple 5.827\n", 
"  XML::RSS::Headline::PerlMonks 0.02\n",
"  Parse::CPAN::Authors 2.27\n", 
"  App::Prove 3.17\n",
"  perlmoduleinstaller 3.1.0\n",
"  B::Concise\n",
"  B::Debug\n",
"  B::Deparse\n",
"  B::C 1.04_20\n",
"  B::LexInfo 0.02\n",
"  B::Lint 1.11\n",
"  B::TerseSize 0.09\n",
"  B::Fathom 0.07\n",
"  B::Xref core\n",
"  Devel::NYTProf 2.10\n",
"  Devel::System::Trace 0.0.2\n",

              "\nYour System:\n",
"  Perl $]\n",
"  OS $^O\n",
"  $0\n";
}
  

sub run_finddeps {
    use CPAN::FindDependencies;
    
    my $mod = prompt("Enter module name: ");

    my @dependencies = CPAN::FindDependencies::finddeps($mod);
    foreach my $dep (@dependencies) {
    print ' ' x $dep->depth();
    print $dep->name().' ('.$dep->distribution().")\n";
  }
}

sub run_finddeps_man {
    system('perldoc CPAN::FindDependencies');
}

sub run_finddeps_smry { print "Finds a module's dependencies\n"; }

sub run_finddeps_help {
    print
"finddeps: At the prompt, enter the name of one module or one distribu
+tion.
It'll return the dependency tree for that module.\n";
}

sub run_mod_info {
    use Module::Info;
    
    my $mod = prompt("Enter module name: ");
    my $info = capture("module_info -a $mod");
    print "$info\n";
} 

sub run_mod_info_man {
    system('perldoc module_info');
}  
    
sub run_mod_info_smry {
     print 
    "Lists: \n",
    "Module name\n",
    "Version\n",
    "Directory\n",
    "if core or not\n",
    "Modules used\n",
    "Packages created\n",
    "Subroutines defined\n";
}

sub run_mod_info_help {
    print
    "mod_info: At the prompt, enter a module name. It'll do the rest.\
+n",
    "run_mod_info can also be adjusted if you want. See mod_info_man t
+o see\n",
    "what other options are available.\n";
}
   
sub run_a {
    CPAN::Shell->a;
}  

sub run_a_smry {
    
 print
    "Returns:\n",
    "a - Returns all authors CPANID, name, and email address\n",
    "\n";
}

sub run_a_help {
print
"Examples: \n",
"Enter at the prompt: \n",
"a\n",
"\n";
}

sub run_d {
    CPAN::Shell->d;
}

sub run_d_smry {
    print
     "d - Returns all distributions, CPANIDs, and email addresses\n",
     "\n";
}

sub run_d_help {
    print
    "Examples: \n",
    "Enter at the prompt: \n",
    "d\n",
    "\n";
}

sub run_ls {
    my $auth = prompt("Enter author's CPANID: ");
    CPAN::Shell->ls($auth);
}

sub run_ls_smry {
    print
    "ls - returns size, release date, CPANID, and Module name\n",
    "\n";
}

sub run_ls_help {
    print
    "Enter at the prompt: \n",
    "ls CPANID\n",
    "\n";
}

sub run_m {
    CPAN::Shell->m;
}

sub run_m_smry {
    print "m - lists all modules on CPAN\n";    
}

sub run_m_help {   
    print
    "m - lists all modules on CPAN, for example:
Module  your    (MSCHWERN/your-1.00.tar.gz)\n";
}

sub run_perlmod {
    my $mod =  prompt("Enter module name: ");
    system("perlmod -i $mod");
    print "We'll double-check using pmpath:\n";
    system("pmpath $mod"); 
    
}

sub run_id {
    my $mod = prompt("Enter module name: ");
    CPAN::Shell->m($mod);
}

sub run_reports {
    my $mod = prompt("Enter module name: ");
    CPAN::Shell->reports($mod);
} 

sub run_cpan_shell_man {
    system('perldoc CPAN');
}

sub run_search {
    use Yahoo::Search;

my $mod = prompt("Enter Yahoo search term: ");

my @Results = Yahoo::Search->Results( Doc   => $mod,
                                      AppId => "YahooDemo",
                                      Mode  => 'all',
                                      Type  => 'html'
                                      );
                                     
for my $Result (@Results) 
  { 
    printf "Result: #%d\n",   $Result->I + 1,
    printf "Url: %s\n",       $Result->Url;
    printf "%s\n",            $Result->ClickUrl;
    printf "Summary: %s\n",   $Result->Summary;
    printf "Title: %s\n",     $Result->Title;
    printf "In Cache: %s\n",  $Result->CacheUrl;
    print "\n";
  }                                
}

sub run_search_man {
    system('perldoc Yahoo::Search');
}

sub run_kwalitee {
    use Module::Release::Kwalitee;
    
my $mod = prompt("Enter path for Kwalitee search: ");
my $kwalitee = capture("cpants_lint.pl $mod") 
         or return &prompt_str;
print $kwalitee, "\n";
}

sub run_kwalitee_man {
    system('perldoc Module::Release::Kwalitee');
}

sub run_visit {
    use CPAN::Mini::Visit;
    
my $auth = prompt("Enter author name: ");

CPAN::Mini::Visit->new(
    minicpan => '/home/kevin/minicpan',
    author   => $auth,
    callback => sub {
        print "$_[0]->{counter} - $_[0]->{dist}\n";
    },
)->run
         or return &prompt_str;
}

sub run_visit_man {
    system('perldoc CPAN::Mini::Visit');
}

sub run_listm {
    my $auth = prompt("Enter author name: ");
    $auth = capture("cpan -L $auth");
    print $auth, "\n";
}    

sub run_parse_backpan {
    use Parse::BACKPAN::Packages;
    
    my $p = Parse::BACKPAN::Packages->new();
    my @authors = $p->authors;
    print "@authors\n";
    print "BACKPAN is " . $p->size . " bytes\n";
}

sub run_parse_backpan_man {
    system('perldoc Parse::BACKPAN::Packages');
}

sub run_readme {
    my $mod = prompt("Enter module name: ");
    CPAN::Shell->readme($mod);
}    
    
sub run_perldoc {
    my $mod = prompt("Enter module name: ");
    my $pd  = capture("perldoc $mod");
    print $pd, "\n";
}   

sub run_perldoc_man {
    system('perldoc perldoc');
} 

sub run_perldoc_m {
    my $mod = prompt("Enter module name: ");
    my $pd  = capture("perldoc -m $mod");
    print $pd, "\n";
}    

sub run_perldoc_f {
    my $func = prompt("Enter function name: ");
    my $pd  = capture("perldoc -f $func");
    print $pd, "\n";
}    

sub run_perldoc_q {
    my $faq = prompt("Enter keyword: ");
    my $pd  = capture("perldoc -q $faq");
    print $pd, "\n";
}              
 
sub run_perldoc_perllocal {
    my $pd = capture("perldoc perllocal");
    print $pd, "\n";
}   

sub run_cat {
    my $ct = prompt("Enter path: ");
    my $ctm = capture("cat $ct");
    print $ctm, "\n";
} 

sub run_cat_man {
    system('man cat');
}

sub run_look {
    my $d = prompt("Enter distribution name: ");
    CPAN::Shell->look($d);
}

sub run_test {
    my $mod = prompt("Enter module name: ");
    CPAN::Shell->test($mod);
} 

sub run_runprove {

    use Test::Run::CmdLine;

    my $mpath = prompt("Enter module path to tests: ");
    my $pr = capture("prove -v --timer $mpath");
    print $pr, "\n";
}  

sub run_prove_man {
     system('perldoc Test::Run::CmdLine');
}                             

sub run_is_core {
    my $core = prompt("Enter module name: ");
    $core    = capture("corelist -a $core");
    print $core, "\n";
}

sub run_is_core_man {
    system('perldoc Module::CoreList');
}

sub run_parse_modlist {

use Parse::CPAN::Modlist;

my $modlist = prompt("Enter path to 03modlist: ");

my $p = Parse::CPAN::Modlist->new($modlist);

foreach my $name ($p->modules) {
    my $module = $p->module($name);
    print " The module '".$module->name."'".
          " is written by ".$module->author.
          " and is described as '".$module->description.
          "'\n";
   }          
}

sub run_parse_modlist_man {
    system('perldoc Parse::CPAN::Modlist');
}

sub run_parse_mod {

use Parse::CPAN::Modlist;

my $name = prompt("Enter module names: ");

my $p = Parse::CPAN::Modlist->new(
'/home/kevin/Desktop/03modlist.data');

my $module = $p->module($name);
   print " The module '".$module->name."'".
          " is written by ".$module->author.
          " and is described as '".$module->description.
          "'\n";
}        

sub run_vers_mod {

    use Module::Versions;

    my $mods = prompt("Enter module name: ");

    my $vers = Module::Versions
               ->new($mods)
               ->list;
}

sub run_vers_mod_man {
    system('perldoc Module::Versions');
}

sub run_parse_ratings {
     
   #at the prompt, enter a distribution like Archive-Zip, not Archive:
+:Zip.
    
    use Parse::CPAN::Ratings;
    use Parse::CPAN::Ratings::Rating;

    my $distribution = prompt("Enter distribution name: ");

    my $ratings = Parse::CPAN::Ratings->new( 
    filename => '/home/kevin/Desktop/all_ratings.csv'
    );   
              
    my $rating = $ratings->rating("$distribution");
    print $rating->distribution . "\n";  
    print $rating->rating . "\n";
    print $rating->review_count . "\n";      
}

sub run_parse_ratings_man {
    system('perldoc Parse::CPAN::Ratings');
}

sub run_acme_kwalitee {
    use Acme::CPANAuthors::Utils::Kwalitee;
    use Data::Dumper::Perltidy;

    my $auth = prompt("Enter author id: ");

    my $info = Acme::CPANAuthors::Utils::Kwalitee->fetch($auth);
    print Dumper  $info;
}

sub run_acme_kwalitee_man {
    system('perldoc Acme::CPANAuthors::Utils::Kwalitee');
}

sub run_pause {

use WWW::PAUSE::RecentUploads;

my $up1 = prompt("Enter login name: ");
my $up2 = prompt("Enter password: ");

my $pause = WWW::PAUSE::RecentUploads->new(
    login => $up1,
    pass  => $up2,
);

my $data = $pause->get_recent
    or die "Failed to fetch data: " . $pause->error;

foreach my $dist ( @$data ) {
    print "$dist->{dist} by $dist->{name} (size: $dist->{size}\n";
} 

sub run_pause_man {
    system('perldoc WWW::PAUSE::RecentUploads');
}           
  
sub run_critic {

    use Perl::Critic;
    
    my $mod = prompt("Enter path to file: ");
    $mod = system("perlcritic --statistics-only $mod");
    print $mod, "\n";
}

sub run_critic_man {
    system('perldoc Perl::Critic');
}

sub run_score {

    use CPAN::Dependency;

    my $mod = prompt("Enter module name: ");

    my $cpandep = new CPAN::Dependency verbose => 1, process => ALL_CP
+AN;
    $cpandep->run;
    $cpandep->calculate_score;

    my $score;
    my %score = $cpandep->score_by_dists;
    my @dists = sort { $score{$b} <=> $score{$a} } keys %score;
    print "Top 10 modules\n";
    for my $dist(@dists[0..9]) {
       printf "%5d %s\n", $score{$dist}, $dist;
} 

sub run_score_man {
    system('perldoc CPAN::Dependency');
}   

sub run_dump_sizes {

    use Devel::DumpSizes qw/dump_sizes/;
    use Data::Dumper::Perltidy;

    my $path = prompt("Enter file path: ");
    &Devel::DumpSizes::dump_sizes($path);

    print Dumper dump_sizes;   
}   

sub run_dump_sizes_man {
    system('perldoc Devel::DumpSizes');
}

sub run_leak {

  #Not that useful now, but it will be later

    use Data::Dumper::Perltidy;
    use Devel::Leak;

    my $handle;

    my $count = Devel::Leak::NoteSV($handle);
    Devel::Leak::CheckSV($handle);

    print Dumper "$count\n, $handle\n";
}

sub run_leak_man {
    system('perldoc Devel::Leak');
}

sub run_prereq {

    use B::PerlReq;

    my $req      = prompt( "Enter path to source" );
    my $con_name = capture("perl.req -v -m strict $req" );
    print $con_name, "\n";
}

sub run_prereq_man {
    system('perldoc B::PerlReq');
}

sub run_con_name {

    use B::PerlReq;

    my $req      = prompt( "Enter path to source" );
    my $con_name = capture("perl.prov -v $req" );
    print $con_name, "\n";
}

sub run_con_name_man {
    system('perldoc B::PerlReq');
}

sub run_used_man {
    sytem('perldoc Module::Used');
}

sub run_details {

use POE;
use CPAN::PackageDetails;

my $package_details = CPAN::PackageDetails->new(
    file         => "02packages.details.txt",
    url          => "ftp://ftp.perl.org/CPAN/modules/02packages.detail
+s.txt",
    description  => "Package names for a private CPAN",
    columns      => "package name, version, path",
    intended_for => "minicpan",
    written_by   => "$0 using CPAN::PackageDetails
                     $CPAN::PackageDetails::VERSION",
    last_updated => "CPAN::PackageDetails->format_date",
    allow_packages_only_once => 0,
);

my $package = 'Some::Package'; 
my $path    = '/path/to/Some/Package.pm';
my $file    = '02packages.details.txt';
my $version = 0.0.1;

$package_details->add_entry(
        package_name => $package,
        version      => $package->VERSION,
        path         => $path
);

print "About to write ", $package_details->count, "entries\n";
$package_details->write_file($file);
$package_details->write_fh(\*STDOUT);
}

sub run_details_man {
    system('perldoc CPAN::PackageDetails');
}

sub run_pmcv {

use File::Spec         ();
use Getopt::Long       ();
use Module::Collection ();

use vars qw{$VERSION};
BEGIN {
    $VERSION = '0.02';
    $| = 1;
}

BEGIN { eval "use Smart::Comments;" }

my $VERBOSE = 0;
my $NEWEST  = 0;
my $MERGED  = 0;
Getopt::Long::GetOptions(
    "verbose+" => \$VERBOSE,
    "newest"   => \$NEWEST,
    "merged"   => \$MERGED,
    );

$NEWEST = 1 if $MERGED;

my $root = defined $ARGV[0]
    ? shift(@ARGV)
    : File::Spec->curdir;

print "Searching for dists... ";
my $collection = Module::Collection->new( root => '/home/kevin/minicpa
+n');

my $found = $collection->dists
    or die "$root does not contain any distributions";
print "found $found\n";

my @dists = $collection->dists;
if ( $NEWEST or $VERBOSE or $MERGED ) {
    foreach ( @dists ) { ### Loading dists [===|   ] %
        $collection->dist($_);
    }
}

$collection->ignore_old_dists if $NEWEST;

print "\n";
foreach my $file ( $collection->dists ) {
    unless ( $VERBOSE ) {
        # Short form
        print "$file\n";
        next;
    }

        my $dist = $collection->dist($file);
    print "\n";
    print "$file\n";
    print "  Name:    " . $dist->dist_name    . "\n";
    print "  Version: " . $dist->dist_version . "\n";
    if ( $VERBOSE >= 2 ) {
        # Regular Dependencies
        my $requires = $dist->dist_requires;
        if ( keys %$requires ) {
            print "  Requires:\n";
            foreach ( sort keys %$requires ) {
                print "    $_: $requires->{$_}\n";
            }
        } else {
            print "  Requires: Nothing\n";
        }

        my $build_requires = $dist->dist_build_requires;
        if ( keys %$build_requires ) {
            print "  Build Requires:\n";
            foreach ( sort keys %$build_requires ) {
                print "    $_: $build_requires->{$_}\n";
            }
        } else {
            print "  Build Requires: Nothing\n";
        }
    }
}

if ( $MERGED ) {
    print "\n";
    print "Listing Merged Depencies:\n";
    my $merged = $collection->depends;
    print $merged->as_string;
}

exit(0);
}

sub run_pmcv_man {
    system('perldoc Module::Collection');
}

sub run_minismokebox {

use App::SmokeBox::Mini;

print      "****SMOKING IS HAZARDOUS TO YOUR HEALTH****\n";

my $warn = prompt("Do you agree with the warning? (yes/no): ");
if ($warn eq 'yes') {
    my $dist = prompt("Enter distribution name : ");
    my $mini = system("minismokebox --debug --package $dist");
}
else {
    print "Sorry! Have a good day!", "\n";
     }        
 
}

sub run_minismokebox_man {
    system('perldoc App::SmokeBox::MIni');
}

sub run_file_size {
    use File::Size;

my $mod = prompt("Enter module name: ");
$mod = File::Size->new(
               dir                       => $mod, 
               blocksize           =>  1024,
               humanreadable  => 1
);
print $mod->getsize(), "\n";
}

sub run_file_size_man {
    system('perldoc File::Size');
}

sub run_sysinfo {
        
       $| = 1;

       use vars qw( $VERSION );
       $VERSION = 0.001;

       use File::Spec;
       use FindBin;
       use lib File::Spec->catdir( $FindBin::Bin, 'lib' );
       use lib $FindBin::Bin;

       use Test::Smoke::SysInfo;

      my $si = Test::Smoke::SysInfo->new ();
      printf "Hostname             : %s\n", $si->host;
      printf "Number of CPU's      : %s\n", $si->ncpu;
      printf "Processor type       : %s\n", $si->cpu_type;   # short
      printf "Processor description: %s\n", $si->cpu;        # long
      printf "OS and version       : %s\n", $si->os;
}

sub run_sysinfo_man {
      system('perldoc Test::Smoke::Info');
}

sub run_versys {

$| = 1;

use vars qw( $VERSION );
$VERSION = 0.001;

use File::Spec;
use FindBin;
use lib File::Spec->catdir( $FindBin::Bin, 'lib' );
use lib $FindBin::Bin;

use Test::Smoke::SysInfo;

my $si = Test::Smoke::SysInfo->new ();
printf "Hostname             : %s\n", $si->host;
printf "Number of CPU's      : %s\n", $si->ncpu;
printf "Processor type       : %s\n", $si->cpu_type;   # short
printf "Processor description: %s\n", $si->cpu;        # long
printf "OS and version       : %s\n", $si->os;

system('perl -V');
}

sub run_pmpath {
    my $mod = prompt("Enter module name: ");
    my $cp = capture("pmpath $mod");
    print "$cp\n";
}

sub run_license {

use Module::License::Report;


my $mod = prompt("Enter module name: ");

my $reporter = Module::License::Report->new();
my $license  = $reporter->license( $mod );
print $license, "\n";
print $license->package_name($mod), "\n";
print $license->package_version($mod), "\n";
print $license->confidence(), "\n";
}

sub run_proctab {

use Proc::ProcessTable;

my $ref = new Proc::ProcessTable;

foreach my $proc (@{$ref->table}) {
  if(@ARGV) {
    next unless grep {$_ == $proc->{pid}} @ARGV;
  }

  print "--------------------------------\n";
  foreach my $field ($ref->fields){
    print $field, ":  ", $proc->{$field}, "\n";
   }
 }
}

sub run_proctab_man {
    system('perldoc Proc::ProcessTable');
}

sub run_infometa {

    use WWW::CPAN;

    my $mod = prompt("Enter module name, using a hyphen instaed of a d
+ouble colon: ");
    my $cap = capture("cpanq meta $mod");
    print $cap, "\n";

}

sub run_probe {

    use Probe::Perl;

    my $p = Probe::Perl->new();

    my $ver   = $p->perl_version();
   $ver      = $p->perl_version_to_float($ver);

    my $path  = $p->find_perl_interpreter();
    my $bool  = $p->perl_is_same($path);

    my @paths = $p->perl_inc();

    my $type  = $p->os_type();

    print $ver,   "\n";
   print $path,  "\n";
   print $bool,  "\n";
   print @paths, "\n";
   print $type,  "\n";
}

sub run_diff {

    use Text::Diff;
    use Text::Diff::Table;

    my $file1 = prompt("Enter file1: ");
    my $file2 = prompt("Enter file2: ");
 

    my $diff = Text::Diff::Table->new;
    $diff = diff $file1, $file2, { STYLE => "Table" };
    print $diff, "\n";
}

sub run_diff_man {
    system("perldoc Text::Diff");
}

sub run_whereis {
    my $app = prompt("Enter name of app: ");
    system("whereis $app");
}

sub run_whereis_man {
    system("man whereis");
}

sub run_du {
    my $dir = prompt("Enter path: ");
    system("du -achk $dir");
}

sub run_du_man {
    system("man du");
}

sub run_z {
    my $cmd = prompt("Enter code: ");
    system($cmd);
}

sub run_recent {
    use App::CPAN::Fast;
    system("cpanf -l");
}

sub run_fetch {
    use File::Fetch;

    $File::Fetch::DEBUG = 1;

    my $fetch = prompt("Enter uri to fetch: ");
    my $there = prompt("Enter where you want the file placed: ");

    my $ff    = File::Fetch->new(uri => $fetch);
    my $where = $ff->fetch(to => $there) or croak $ff->error;
  }  
 }  
} 

sub run_123 {

use Net::FTP;

use constant HOST  => 'ftp.cpan.org';
use constant DIR1  => '/pub/CPAN/authors';
use constant FILE1 => '01mailrc.txt.gz';
use constant DIR2  => '/pub/CPAN/modules';
use constant FILE2 => '02packages.details.txt.gz';
use constant FILE3 => '03modlist.data.gz';

my $ftp = Net::FTP->new(
    HOST, 
    Debug => 1, 
    Passive => 1, 
    Timeout => 1
);

$ftp->login('anonymous');
$ftp->cwd(DIR1);
$ftp->ascii;
$ftp->get(FILE1);
$ftp->cwd(DIR2);
$ftp->get(FILE2);
$ftp->size(FILE2);
$ftp->get(FILE3);
$ftp->quit;
}

#sub run_cover {

#use Devel::Cover; 
#use Data::Dumper; 
      
#my $cov = prompt("Enter your path to program: ");
#$cov = system(
       #cover has some problems...working on fix
      # "perl -MDevel::Cover $cov cover"
#);
#print Dumper $cov, "\n";
#}

sub run_up {

no warnings;
use XML::RSS::Feed;
use XML::RSS::Headline::UsePerlJournals;
use LWP::Simple qw(get);

my $feed = XML::RSS::Feed->new(
    name  => "useperljournals",
    hlobj => "XML::RSS::Headline::UsePerlJournals",
    delay => 60,
    url   => "http://use.perl.org/search.pl?tid=&query=&"
             . "author=&op=journals&content_type=rss",
);

while (1) {
    $feed->parse(get($feed->url));
    print $_->headline . "\n" for $feed->late_breaking_news;
    sleep($feed->delay);
}

sub run_monk {

use XML::RSS::Feed;
use XML::RSS::Headline::PerlMonks;
use LWP::Simple qw(get);

my $feed = XML::RSS::Feed->new(
  name    => "newmonknodes",
  url     => "http://perlmonks.org/index.pl?node_id=30175;xmlstyle=rss
+",
  hlobj   => "XML::RSS::Headline::PerlMonks",
  tmpdir  => "/Users/rafferty/Desktop/tmp",
);

while (1) {
    $feed->parse( get( $feed->url ) );
    for my $post ( $feed->late_breaking_news ) {
        print "New perlmonks posting from " . $post->authortitle . "\n
+";
        print "Category: " . $post->category . "\n";
        print "Subject: " . $post->headline . "\n";
        print "Link: " . $post->url . "\n\n";
    }
    return &prompt_str
 }
}

sub run_parse_cpan {

use Data::Dumper;
use Parse::CPAN::Authors;

my $m = prompt("Enter path to 01mailrc.txt.gz: "); 

my $p = Parse::CPAN::Authors->new( $m );
my @authors = $p->authors;

print Dumper @authors, "\n";
  }
 
}

sub run_func_list {

system('pmpath Pod::Functions');

my $f = prompt("Enter path to Pod::Functions: \n");
system("perl $f");
}

sub run_builtin_vars {

use B::Keywords qw( @Symbols @Barewords );
print join "\n", @Symbols,
                 @Barewords,
                  "\n";
}

sub run_checkenv {

foreach (sort keys %ENV) {
    print "$_ = $ENV{$_}\n";
  }  
}

sub run_pler {
    my $t = prompt("Enter path to test: ");
    system("perl $t");
}
{
sub run_explain {

use YAPE::Regex::Explain;

    my $re  = prompt("Enter regexp: ");
    my $exp = YAPE::Regex::Explain->new($re)->explain;
    print $exp, "\n";
}


sub run_bench {

use Benchmark::Timer;

use Statistics::TTest;
use Statistics::Distributions;
use Statistics::Descriptive;

my $bn = prompt("Enter code to benchmark: ");

my $t = Benchmark::Timer->new(skip => 0, minimum => 10, confidence => 
+97.5, error => 2);

while($t->need_more_samples($bn)) {
    $t->start($bn);
    sleep(5);
    $t->stop($bn);
  }
print $t->report;
}

sub run_profiler {

use Devel::Profiler;

my $mod = prompt("Enter path to script to test: ");
my $scr = system("perl -MDevel::Profiler $mod");
print $scr, "\n";
system('dprofpp -u');

}

sub run_find_exe {

use File::Spec;
use SVN::Notify;

    my $exe_name = prompt("Enter name of executable: ");
    my $exe = SVN::Notify->find_exe($exe_name);
    print "$exe\n";
  }  
}

sub run_cpan {
    system("cpan");
}

sub run_cpanp {
    system("cpanp");
}

sub run_concise {
    my $prog = prompt("Enter program name: ");
    system("perl -MO=Concise,-tree $prog");
}

sub run_modebug {
    my $prog = prompt("Enter program name: ");
    system("perl -MO=Debug $prog");
}

sub run_deparse { 
    my $prog = prompt("Enter program name: ");
    system("perl -MO=Deparse,d,l,-P,-x7 $prog");
}

sub run_namespace {
    my $mod = prompt("Enter namespace to check: ");
    CPAN::Shell->m($mod);
}

sub run_c {
    use B::C;
    my $mod = prompt("Enter module name: ");
    exec("perl -MO=C,-v, $mod");
}

sub run_lex {

    use B::LexInfo;
    use B::ShowLex ();

    my $mod = prompt("Enter package name: ");

    my $lexi = B::LexInfo->new;
    my $before = $lexi->stash_cvlexinfo($mod);
    my $after = $lexi->stash_cvlexinfo($mod);
    my $diff = $lexi->diff($before, $after);
    print Dumper "$before, $after, $diff\n";
}

sub run_lint {
    use B::Lint;
    my $mod = prompt("Enter program name: ");
    system("perl -MO=Lint,-all $mod");
}

sub run_terse_size {
    use B::TerseSize;
    my $mod = prompt("Enter program name: ");
    system("perl -MO=TerseSize,-v $mod");
}

sub run_fathom {
    use B::Fathom;
    my $mod = prompt("Enter code: ");
    system("perl -MO=Fathom,-v $mod");
}

sub run_xref {
    use B::Xref;
    my $mod = prompt("Enter file name: ");
    system("perl -MO=Xref,-DtO $mod");
}


sub run_find_lib {
    use Devel::CheckLib;
    my $mod = prompt("Enter name of lib: ");
    check_lib_or_exit( lib => [ $mod ] );
}

sub run_nytprof {
     use Devel::NYTProf;
     my $mod = prompt("Enter filename: ");
     system("perl -d:NYTProf $mod");
     system("nytprofcsv");
}

sub run_wc {

use IPC::System::Simple qw(capture);

my $mod = prompt("Enter path to file: ");
my $lines = capture("wc -clmw $mod");
print "$lines\n";
}
[download]