view release on metacpan or  search on metacpan

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

            die "Error: No MYMETA.json after executing $build_file\n";
        }
        return { type => 'metafile', path => 'MYMETA.json' };
    }
    return;
}

sub load_dependency_file ($self, $ctx) {
    my $cpmfile = do {
        my ($type, $path) = $self->{dependency_file}->@{qw(type path)};
        warn "Loading requirements from $path...\n";
        if ($type eq "cpmfile") {
            Module::cpmfile->load($path);
        } elsif ($type eq "cpanfile") {
            Module::cpmfile->from_cpanfile(Module::CPANfile->load($path));
        } elsif ($type eq "metafile") {
            Module::cpmfile->from_cpanmeta(CPAN::Meta->load_file($path));
        } else {
            die;
        }
    };
    if (!$self->{mirror}) {
        my $mirrors = $cpmfile->{_mirrors} || [];
        if ($mirrors->@*) {
            $self->{mirror} = $self->normalize_mirror($mirrors->[0]);
        } else {
            $self->{mirror} = $self->{_default_mirror};
        }
    }
    my @phase = $self->{top_level_phase}->@*;
    my @type = $self->{top_level_relationship}->@*;
    my $reqs = $cpmfile->effective_requirements($self->{feature}, \@phase, \@type);

    my (@package, @reinstall);
    for my $package (sort keys $reqs->%*) {
        my $options = $reqs->{$package};
        my $req = {
            package => $package,
            version_range => $options->{version},
            dev => $options->{dev},
            reinstall => $package ne "perl" && ($self->{reinstall} || $options->{git}) ? 1 : 0,
        };
        if ($req->{reinstall}) {
            push @reinstall, $req;
        } else {
            push @package, $req;
        }
    }

    require App::cpm::Resolver::Custom;
    my $resolver = App::cpm::Resolver::Custom->new(
        $ctx,
        requirements => $reqs,
        mirror => $self->{mirror},
        from => $self->{dependency_file}{type},
    );
    return (\@package, \@reinstall, $resolver->effective ? $resolver : undef);
}

sub generate_resolver ($self, $ctx, $initial) {
    my $cascade = App::cpm::Resolver::Cascade->new($ctx);
    $cascade->add($initial) if $initial;
    if ($self->{resolver}->@*) {
        for my $r ($self->{resolver}->@*) {
            my ($klass, @argv) = split /,/, $r;
            my $resolver = $self->_generate_resolver($ctx, $klass, @argv);
            $cascade->add($resolver);
        }
    }
    return $cascade if !$self->{default_resolvers};

    if ($self->{mirror_only}) {
        require App::cpm::Resolver::02Packages;
        my $resolver = App::cpm::Resolver::02Packages->new(
            $ctx,
            mirror => $self->{mirror},
            cache => "$self->{home}/sources",
        );
        $cascade->add($resolver);
        return $cascade;
    }

    if (!$self->{argv} and -f $self->{snapshot}) {
        if (!eval { require App::cpm::Resolver::Snapshot }) {
            die "To load $self->{snapshot}, you need to install Carton::Snapshot.\n";
        }
        warn "Loading distributions from $self->{snapshot}...\n";
        my $resolver = App::cpm::Resolver::Snapshot->new(
            $ctx,
            path => $self->{snapshot},
            mirror => $self->{mirror},
        );
        $cascade->add($resolver);
    }

    my $resolver = App::cpm::Resolver::MetaCPAN->new(
        $ctx,
        $self->{dev} ? (dev => 1) : (only_dev => 1)
    );
    $cascade->add($resolver);
    $resolver = App::cpm::Resolver::MetaDB->new(
        $ctx,
        uri => $self->{cpanmetadb},
        mirror => $self->{mirror},
    );
    $cascade->add($resolver);
    if (!$self->{dev}) {
        $resolver = App::cpm::Resolver::MetaCPAN->new($ctx);
        $cascade->add($resolver);
    }

    $cascade;
}

sub _generate_resolver ($self, $ctx, $klass, @argv) {
    if ($klass =~ /^metadb$/i) {
        my ($uri, $mirror);
        if (@argv > 1) {
            ($uri, $mirror) = @argv;
        } elsif (@argv == 1) {
            $mirror = $argv[0];
        } else {
            $mirror = $self->{mirror};
        }
        return App::cpm::Resolver::MetaDB->new(
            $ctx,
            $uri ? (uri => $uri) : (),
            mirror => $self->normalize_mirror($mirror),
        );
    } elsif ($klass =~ /^metacpan$/i) {
        return App::cpm::Resolver::MetaCPAN->new($ctx, dev => $self->{dev});
    } elsif ($klass =~ /^02packages?$/i) {
        require App::cpm::Resolver::02Packages;
        my ($path, $mirror);
        if (@argv > 1) {
            ($path, $mirror) = @argv;
        } elsif (@argv == 1) {
            $mirror = $argv[0];
        } else {
            $mirror = $self->{mirror};
        }
        return App::cpm::Resolver::02Packages->new(
            $ctx,
            $path ? (path => $path) : (),
            cache => "$self->{home}/sources",
            mirror => $self->normalize_mirror($mirror),
        );
    } elsif ($klass =~ /^snapshot$/i) {
        require App::cpm::Resolver::Snapshot;
        return App::cpm::Resolver::Snapshot->new(
            $ctx,
            path => $self->{snapshot},
            mirror => @argv ? $self->normalize_mirror($argv[0]) : $self->{mirror},
        );
    }
    my $full_klass = $klass =~ s/^\+// ? $klass : "App::cpm::Resolver::$klass";
    (my $file = $full_klass) =~ s{::}{/}g;
    require "$file.pm"; # may die
    return $full_klass->new($ctx, @argv);
}

my $HELP = <<'EOF';
Usage: cpm install [OPTIONS...] ARGV...

Examples:
  # install modules into local/
  > cpm install Module1 Module2 ...

  # install modules from one of
  #  * cpm.yml
  #  * cpanfile
  #  * META.json (with dynamic_config false)