view release on metacpan or  search on metacpan

kritika.fatpack  view on Meta::CPAN

  use strict;use warnings;package Test::Deep;use Carp qw(confess);use Test::Deep::Cache;use Test::Deep::Stack;use Test::Deep::RegexpVersion;require overload;use Scalar::Util;my$Test;unless (defined$Test::Deep::NoTest::NoTest){require Test::Builder;$T...
  $message
     got : $got
  expect : $expected
  EOM
TEST_DEEP

$fatpacked{"Test/Deep/All.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ALL';
  use strict;use warnings;package Test::Deep::All;use Scalar::Util ();use Test::Deep::Cmp;sub init {my$self=shift;my@list=map {(Scalar::Util::blessed($_)&& $_->isa('Test::Deep::All'))? @{$_->{val}}: $_}@_;$self->{val}=\@list}sub descend {my$self=shif...
TEST_DEEP_ALL

$fatpacked{"Test/Deep/Any.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ANY';
  use strict;use warnings;package Test::Deep::Any;use Scalar::Util ();use Test::Deep::Cmp;sub init {my$self=shift;my@list=map {(Scalar::Util::blessed($_)&& $_->isa('Test::Deep::Any'))? @{$_->{val}}: $_}@_;$self->{val}=\@list}sub descend {my$self=shif...
  Comparing $where with Any
  got      : $got
  expected : $exp
  EOM
TEST_DEEP_ANY

$fatpacked{"Test/Deep/Array.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ARRAY';
  use strict;use warnings;package Test::Deep::Array;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};return 0 unless Test::Deep::descend($got,Test::Deep::arraylengt...
TEST_DEEP_ARRAY

$fatpacked{"Test/Deep/ArrayEach.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ARRAYEACH';
  use strict;use warnings;package Test::Deep::ArrayEach;use Test::Deep::Cmp;use Scalar::Util ();sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;return unless ref$got && Scalar::Util::reftype($got)eq 'ARR...
TEST_DEEP_ARRAYEACH

$fatpacked{"Test/Deep/ArrayElementsOnly.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ARRAYELEMENTSONLY';
  use strict;use warnings;package Test::Deep::ArrayElementsOnly;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};my$data=$self->data;for my$i (0..$#{$exp}){$data->{...
TEST_DEEP_ARRAYELEMENTSONLY

$fatpacked{"Test/Deep/ArrayLength.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ARRAYLENGTH';
  use strict;use warnings;package Test::Deep::ArrayLength;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};return 0 unless$self->test_reftype($got,"ARRAY");return T...
TEST_DEEP_ARRAYLENGTH

$fatpacked{"Test/Deep/ArrayLengthOnly.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ARRAYLENGTHONLY';
  use strict;use warnings;package Test::Deep::ArrayLengthOnly;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$len=$self->{val};return @$got==$len}sub render_stack {my$self=shift;my...
TEST_DEEP_ARRAYLENGTHONLY

$fatpacked{"Test/Deep/Blessed.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_BLESSED';
  use strict;use warnings;package Test::Deep::Blessed;use Test::Deep::Cmp;use Scalar::Util qw(blessed);sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};my$blessed=blessed($got);return ...
TEST_DEEP_BLESSED

$fatpacked{"Test/Deep/Boolean.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_BOOLEAN';
  use strict;use warnings;package Test::Deep::Boolean;use Test::Deep::Cmp;sub init {my$self=shift;$self->{val}=shift()? 1 : 0}sub descend {my$self=shift;my$got=shift;return!($got xor $self->{val})}sub diag_message {my$self=shift;my$where=shift;return...
TEST_DEEP_BOOLEAN

$fatpacked{"Test/Deep/Cache.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_CACHE';
  use strict;use warnings;package Test::Deep::Cache;use Test::Deep::Cache::Simple;sub new {my$pkg=shift;my$self=bless {},$pkg;$self->{expects}=[Test::Deep::Cache::Simple->new];$self->{normal}=[Test::Deep::Cache::Simple->new];$self->local;return$self}...
TEST_DEEP_CACHE

$fatpacked{"Test/Deep/Cache/Simple.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_CACHE_SIMPLE';
  use strict;use warnings;package Test::Deep::Cache::Simple;use Carp qw(confess);use Scalar::Util qw(refaddr);BEGIN {if (grep /^weaken$/,@Scalar::Util::EXPORT_FAIL){*weaken=sub {}}else {Scalar::Util->import('weaken')}}sub new {my$pkg=shift;my$self=bl...
TEST_DEEP_CACHE_SIMPLE

$fatpacked{"Test/Deep/Class.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_CLASS';
  use strict;use warnings;package Test::Deep::Class;use Test::Deep::Cmp;sub init {my$self=shift;my$snobby=shift;my$val=shift;$self->{snobby}=$snobby;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;local$Test::Deep::Snobby=$self->{snobby};Te...
TEST_DEEP_CLASS

$fatpacked{"Test/Deep/Cmp.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_CMP';
  use strict;use warnings;package Test::Deep::Cmp;use overload '&'=>\&make_all,'|'=>\&make_any,'""'=>\&string,fallback=>1,;use Scalar::Util ();sub import {my$pkg=shift;my$callpkg=caller();if ($callpkg =~ /^Test::Deep::/){no strict 'refs';push @{$call...
TEST_DEEP_CMP

$fatpacked{"Test/Deep/Code.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_CODE';
  use strict;use warnings;package Test::Deep::Code;use Test::Deep::Cmp;sub init {my$self=shift;my$code=shift || die "No coderef supplied";$self->{code}=$code}sub descend {my$self=shift;my$got=shift;my ($ok,$diag)=&{$self->{code}}($got);$self->data->{...
  Ran coderef at $where on
  
  $data
  EOM
  and it said
  $error
  EOM
  it failed but it didn't say why.
  EOM
TEST_DEEP_CODE

$fatpacked{"Test/Deep/Hash.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_HASH';
  use strict;use warnings;package Test::Deep::Hash;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};my$data=$self->data;return 0 unless Test::Deep::descend($got,$se...
TEST_DEEP_HASH

$fatpacked{"Test/Deep/HashEach.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_HASHEACH';
  use strict;use warnings;package Test::Deep::HashEach;use Test::Deep::Cmp;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my%exp;@exp{keys %$got}=($self->{val})x (keys %$got);return Test::Deep::descend(...
TEST_DEEP_HASHEACH

$fatpacked{"Test/Deep/HashElements.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_HASHELEMENTS';
  use strict;use warnings;package Test::Deep::HashElements;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};my$data=$self->data;my$master=$self->getMaster($got,$exp...
TEST_DEEP_HASHELEMENTS

$fatpacked{"Test/Deep/HashKeys.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_HASHKEYS';
  use strict;use warnings;package Test::Deep::HashKeys;use Test::Deep::Ref;sub init {my$self=shift;my%keys;@keys{@_}=();$self->{val}=\%keys;$self->{keys}=[sort @_]}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};return 0 unless$self->test...
TEST_DEEP_HASHKEYS

$fatpacked{"Test/Deep/HashKeysOnly.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_HASHKEYSONLY';
  use strict;use warnings;package Test::Deep::HashKeysOnly;use Test::Deep::Ref;sub init {my$self=shift;my%keys;@keys{@_}=();$self->{val}=\%keys;$self->{keys}=[sort @_]}sub descend {my$self=shift;my$hash=shift;my$data=$self->data;my$exp=$self->{val};m...
  Comparing hash keys of $where
  $error
  EOM
TEST_DEEP_HASHKEYSONLY

$fatpacked{"Test/Deep/Ignore.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_IGNORE';
  use strict;use warnings;package Test::Deep::Ignore;use Test::Deep::Cmp;my$Singleton=__PACKAGE__->SUPER::new;sub new {return$Singleton}sub descend {return 1}1;
TEST_DEEP_IGNORE

$fatpacked{"Test/Deep/Isa.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ISA';
  use strict;use warnings;package Test::Deep::Isa;use Test::Deep::Cmp;use Scalar::Util;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;return Scalar::Util::blessed($got)? $got->isa($self->{val}): ref($go...
TEST_DEEP_ISA

$fatpacked{"Test/Deep/ListMethods.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_LISTMETHODS';
  use strict;use warnings;package Test::Deep::ListMethods;use base 'Test::Deep::Methods';sub call_method {my$self=shift;return [$self->SUPER::call_method(@_)]}sub render_stack {my$self=shift;my$var=$self->SUPER::render_stack(@_);return "[$var]"}1;
TEST_DEEP_LISTMETHODS

$fatpacked{"Test/Deep/MM.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_MM';
  use strict;use warnings;package Test::Deep::MM;sub import {my$self=shift;my ($pkg)=caller();my$mpkg=$pkg."::Methods";for my$attr (@_){if ($attr =~ /^[a-z]/){no strict 'refs';*{$mpkg."::$attr"}=\&{$attr}}else {my$get_name=$mpkg."::get$attr";my$set_n...
TEST_DEEP_MM

$fatpacked{"Test/Deep/Methods.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_METHODS';
  use strict;use warnings;package Test::Deep::Methods;use Test::Deep::Cmp;use Scalar::Util;sub init {my$self=shift;my@methods;while (@_){my$name=shift;my$value=shift;push(@methods,[ref($name)? $name : [$name ],$value ])}$self->{methods}=\@methods}sub...
TEST_DEEP_METHODS

$fatpacked{"Test/Deep/NoTest.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_NOTEST';
  use strict;use warnings;package Test::Deep::NoTest;our$NoTest;{local$NoTest=1;require Test::Deep}sub import {my$import=Test::Deep->can("import");my$pkg=shift;unshift(@_,"Test::Deep");goto &$import}1;
TEST_DEEP_NOTEST

$fatpacked{"Test/Deep/None.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_NONE';
  use strict;use warnings;package Test::Deep::None;use Test::Deep::Cmp;sub init {my$self=shift;my@list=map {eval {$_->isa('Test::Deep::None')}? @{$_->{val}}: $_}@_;$self->{val}=\@list}sub descend {my$self=shift;my$got=shift;for my$cmp (@{$self->{val}...
  Comparing $where with None
  got      : $got
  expected : $exp
  EOM
TEST_DEEP_NONE

$fatpacked{"Test/Deep/Number.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_NUMBER';
  use strict;use warnings;package Test::Deep::Number;use Test::Deep::Cmp;use Scalar::Util;sub init {my$self=shift;$self->{val}=shift(@_)+ 0;$self->{tolerance}=shift}sub descend {my$self=shift;my$got=shift;$self->data->{got_string}=$got;{no warnings '...
TEST_DEEP_NUMBER

$fatpacked{"Test/Deep/Obj.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_OBJ';
  use strict;use warnings;package Test::Deep::Obj;use Test::Deep::Cmp;use Scalar::Util;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;return Scalar::Util::blessed($got)&& $got->isa($self->{val})}sub dia...
TEST_DEEP_OBJ

$fatpacked{"Test/Deep/Ref.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REF';
  use strict;use warnings;package Test::Deep::Ref;use Test::Deep::Cmp;use Scalar::Util qw(blessed);sub test_class {my$self=shift;my$got=shift;my$exp=$self->{val};if ($Test::Deep::Snobby){return Test::Deep::descend($got,Test::Deep::blessed(blessed($ex...
TEST_DEEP_REF

$fatpacked{"Test/Deep/RefType.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REFTYPE';
  use strict;use warnings;package Test::Deep::RefType;use Test::Deep::Cmp;use Scalar::Util qw(reftype);sub init {my$self=shift;$self->{val}=shift}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};my$reftype=reftype($got);return Test::Deep::...
TEST_DEEP_REFTYPE

$fatpacked{"Test/Deep/Regexp.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REGEXP';
  use strict;use warnings;package Test::Deep::Regexp;use Test::Deep::Cmp;use Test::Deep::RegexpMatches;sub init {my$self=shift;my$val=shift;$val=ref$val ? $val : qr/$val/;$self->{val}=$val;if (my$matches=shift){$self->{matches}=Test::Deep::regexpmatc...
TEST_DEEP_REGEXP

$fatpacked{"Test/Deep/RegexpMatches.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REGEXPMATCHES';
  use strict;use warnings;package Test::Deep::RegexpMatches;use Test::Deep::Array;use base 'Test::Deep::Array';use Scalar::Util qw(blessed);sub init {my$self=shift;my$val=shift;$val=Test::Deep::array($val)unless blessed($val)and $val->isa("Test::Deep...
TEST_DEEP_REGEXPMATCHES

$fatpacked{"Test/Deep/RegexpOnly.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REGEXPONLY';
  use strict;use warnings;package Test::Deep::RegexpOnly;use Test::Deep::Cmp;use Scalar::Util qw(blessed);sub init {my$self=shift;my$val=shift;$val=ref$val ? $val : qr/$val/;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$re=$self->{val}...
TEST_DEEP_REGEXPONLY

$fatpacked{"Test/Deep/RegexpRef.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REGEXPREF';
  use strict;use warnings;package Test::Deep::RegexpRef;use Test::Deep::Ref;use Test::Deep::RegexpVersion;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};if ($Test::Deep::RegexpVersio...
TEST_DEEP_REGEXPREF

$fatpacked{"Test/Deep/RegexpRefOnly.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REGEXPREFONLY';
  use strict;use warnings;package Test::Deep::RegexpRefOnly;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};return$got eq $exp}sub render_stack {my$self=shift;my (...
TEST_DEEP_REGEXPREFONLY

$fatpacked{"Test/Deep/RegexpVersion.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REGEXPVERSION';
  use strict;use warnings;package Test::Deep::RegexpVersion;our$OldStyle=($] < 5.011);1;
TEST_DEEP_REGEXPVERSION

$fatpacked{"Test/Deep/ScalarRef.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_SCALARREF';
  use strict;use warnings;package Test::Deep::ScalarRef;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};return 0 unless$self->test_class($got);return 0 unless$self...
TEST_DEEP_SCALARREF

$fatpacked{"Test/Deep/ScalarRefOnly.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_SCALARREFONLY';
  use strict;use warnings;package Test::Deep::ScalarRefOnly;use Test::Deep::Cmp;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};return Test::Deep::descend($$got,$$exp)}sub render_stac...
TEST_DEEP_SCALARREFONLY

$fatpacked{"Test/Deep/Set.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_SET';
  use strict;use warnings;package Test::Deep::Set;use Test::Deep::Cmp;sub init {my$self=shift;$self->{IgnoreDupes}=shift;$self->{SubSup}=shift;$self->{val}=[];$self->add(@_)}sub descend {my$self=shift;my$d1=shift;my$d2=$self->{val};my$IgnoreDupes=$se...
  got    : $got
  expect : An array to use as a $type
  EOM
  Comparing $where as a $type
  $error
  EOM
TEST_DEEP_SET

$fatpacked{"Test/Deep/Shallow.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_SHALLOW';
  use strict;use warnings;package Test::Deep::Shallow;use Test::Deep::Cmp;use Scalar::Util qw(refaddr);sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};my$ok;if (!defined$got and!defin...
TEST_DEEP_SHALLOW

$fatpacked{"Test/Deep/Stack.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_STACK';
  use strict;use warnings;package Test::Deep::Stack;use Carp qw(confess);use Scalar::Util;use Test::Deep::MM qw(new init Stack Arrow);sub init {my$self=shift;$self->SUPER::init(@_);$self->setStack([])unless$self->getStack}sub push {my$self=shift;push...
TEST_DEEP_STACK

$fatpacked{"Test/Deep/String.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_STRING';
  use strict;use warnings;package Test::Deep::String;use Test::Deep::Cmp;sub init {my$self=shift;$self->{val}=shift}sub descend {my$self=shift;my$got=shift()."";$self->data->{got}=$got;return$got eq $self->{val}}sub diag_message {my$self=shift;my$whe...
TEST_DEEP_STRING

$fatpacked{"Test/Fatal.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_FATAL';
  use strict;use warnings;package Test::Fatal;$Test::Fatal::VERSION='0.05';use Carp ();use Try::Tiny 0.07;use Exporter 5.57 'import';our@EXPORT=qw(exception);our@EXPORT_OK=qw(exception success dies_ok lives_ok);our ($REAL_TBL,$REAL_CALCULATED_TBL)=(1...
TEST_FATAL

$fatpacked{"Test/MonkeyMock.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_MONKEYMOCK';
  package Test::MonkeyMock;use strict;use warnings;require Carp;our$VERSION='0.05';my$registry={};my$magic_counter=0;sub new {my$class=shift;$class=ref$class if ref$class;my ($instance)=@_;my$new_package;if ($instance){$new_package=__PACKAGE__ .'::' ...
TEST_MONKEYMOCK

$fatpacked{"Test/TempDir/Tiny.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_TEMPDIR_TINY';
  use 5.006002;use strict;use warnings;package Test::TempDir::Tiny;our$VERSION='0.05';use Exporter 5.57 qw/import/;our@EXPORT=qw/tempdir in_tempdir/;use Carp qw/confess/;use Cwd qw/abs_path/;use Errno qw/EEXIST ENOENT/;{no warnings 'numeric';use File...
TEST_TEMPDIR_TINY

$fatpacked{"Try/Tiny.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TRY_TINY';
  package Try::Tiny;use 5.006;our$VERSION='0.05';use strict;use warnings;use Exporter 5.57 'import';our@EXPORT=our@EXPORT_OK=qw(try catch finally);use Carp;$Carp::Internal{+__PACKAGE__}++;BEGIN {my$su=$INC{'Sub/Util.pm'}&& defined&Sub::Util::set_subn...
TRY_TINY

s/^  //mg for values %fatpacked;

my $class = 'FatPacked::'.(0+\%fatpacked);
no strict 'refs';
*{"${class}::files"} = sub { keys %{$_[0]} };

if ($] < 5.008) {
  *{"${class}::INC"} = sub {
    if (my $fat = $_[0]{$_[1]}) {
      my $pos = 0;
      my $last = length $fat;
      return (sub {
        return 0 if $pos == $last;
        my $next = (1 + index $fat, "\n", $pos) || $last;
        $_ .= substr $fat, $pos, $next - $pos;
        $pos = $next;
        return 1;
      });
    }
  };
}

else {
  *{"${class}::INC"} = sub {
    if (my $fat = $_[0]{$_[1]}) {
      open my $fh, '<', \$fat
        or die "FatPacker error loading $_[1] (could be a perl installation issue?)";
      return $fh;
    }
    return;
  };
}

unshift @INC, bless \%fatpacked, $class;
  } # END OF FATPACK CODE


use strict;
use warnings;

use Getopt::Long;
use App::Kritika;
use App::Kritika::Settings;

my $opt_diff_branch;
my $opt_diff_ref;
my $opt_diff_snapshot;
GetOptions(
    'diff-branch=s'   => \$opt_diff_branch,
    'diff-ref=s'      => \$opt_diff_ref,
    'diff-snapshot=i' => \$opt_diff_snapshot,
) or die("Error in command line arguments\n");

my @files;

if ( !-t STDIN ) {
    @files = map { chomp $_; $_ } <>;
}