File Coverage

lib/Mojolicious/Plugin/Fondation/Command/fondation.pm

Criterion	Covered	Total	%
statement	79	164	48.1
branch	7	36	19.4
condition	10	23	43.4
subroutine	9	16	56.2
pod	1	1	100.0
total	106	240	44.1

package Mojolicious::Plugin::Fondation::Command::fondation;

# ABSTRACT: Fondation orchestration commands -- init, upgrade, refresh

use Mojo::Base 'Mojolicious::Command', -signatures;

use utf8;
use Mojo::File 'path';
use File::Path qw(remove_tree);

our $VERSION = '0.01';

has description => 'Orchestrate Fondation plugins: init, upgrade, refresh';
has usage       => sub ($self) {
    <<"USAGE";
Usage: APPLICATION fondation COMMAND [OPTIONS]

  myapp.pl db bootstrap-schema    Create the schema class (run once)
  myapp.pl fondation plan init    Preview init steps (dry-run)
  myapp.pl fondation plan upgrade Preview upgrade steps (dry-run)
  myapp.pl fondation plan refresh Preview refresh steps (dry-run)
  myapp.pl fondation init         First-time setup for all plugins
  myapp.pl fondation upgrade      Detect drift, upgrade, regenerate
  myapp.pl fondation refresh      Clean all generated artifacts and regenerate

USAGE
};

# ---------------------------------------------------------------------------
# Entry point
# ---------------------------------------------------------------------------

sub run ($self, @args) {
    my $app        = $self->app;
    my $subcommand = shift @args || '';

    die $self->usage unless $subcommand;

    for ($subcommand) {
        /^plan$/    and return $self->_run_plan($app, shift @args || '');
        /^init$/    and return $self->_run_init($app);
        /^upgrade$/ and return $self->_run_upgrade($app);
        /^refresh$/ and return $self->_run_refresh($app);
        die $self->usage;
    }
}

# ---------------------------------------------------------------------------
# Run a list of steps through $app->commands->run()
# ---------------------------------------------------------------------------

sub _run_steps ($self, $app, $step_name, $long_name, $steps) {
    for my $step (@$steps) {
        my @cmd = ref $step eq 'ARRAY' ? @$step : ($step);
        $app->commands->run(@cmd);
    }
}

# ---------------------------------------------------------------------------
# Collect steps from all plugins in load order
# ---------------------------------------------------------------------------

sub _collect_steps ($self, $app, $key) {
    my @steps;
    for my $long (@{ $app->manager->load_order }) {
        my $entry = $app->manager->registry->{$long};
        my $cfg   = $entry->{config} // {};
        my $plugin_steps = $cfg->{$key};
        next unless $plugin_steps && ref $plugin_steps eq 'ARRAY' && @$plugin_steps;
        push @steps, { long_name => $long, steps => $plugin_steps };
    }
    return @steps;
}

# ---------------------------------------------------------------------------
# Collect clean targets from all plugins in load order
# ---------------------------------------------------------------------------

sub _collect_clean ($self, $app) {
    my @targets;
    for my $long (@{ $app->manager->load_order }) {
        my $entry = $app->manager->registry->{$long};
        my $cfg   = $entry->{config} // {};
        my $plugin_clean = $cfg->{fondation_clean};
        next unless $plugin_clean && ref $plugin_clean eq 'ARRAY' && @$plugin_clean;
        push @targets, { long_name => $long, targets => $plugin_clean };
    }
    return @targets;
}

# ---------------------------------------------------------------------------
# fondation plan (dry-run preview)
# ---------------------------------------------------------------------------

sub _run_plan ($self, $app, $subcommand) {
    die $self->usage unless $subcommand;

    for ($subcommand) {
        /^init$/    and return $self->_show_plan_init($app);
        /^upgrade$/ and return $self->_show_plan_upgrade($app);
        /^refresh$/ and return $self->_show_plan_refresh($app);
        die $self->usage;
    }
}

sub _short_name ($self, $app, $long) {
    return $app->manager->registry->{$long}{short_name} // $long;
}

sub _show_plan_init ($self, $app) {
    my @plugins = $self->_collect_steps($app, 'fondation_init');
    my $total_steps = 0;

    for my $p (@plugins) {
        my $short = $self->_short_name($app, $p->{long_name});
        say "-- $short";
        for my $step (@{ $p->{steps} }) {
            my @cmd = ref $step eq 'ARRAY' ? @$step : ($step);
            say "   [run] @cmd";
            $total_steps++;
        }
    }

    say "-- Init plan: " . scalar(@plugins) . " plugins, $total_steps steps --";
}

sub _show_plan_upgrade ($self, $app) {
    my @plugins = $self->_collect_steps($app, 'fondation_upgrade');
    my $total_steps = 0;

    for my $p (@plugins) {
        my $short = $self->_short_name($app, $p->{long_name});
        say "-- $short";
        for my $step (@{ $p->{steps} }) {
            my @cmd = ref $step eq 'ARRAY' ? @$step : ($step);
            say "   [run] @cmd";
            $total_steps++;
        }
    }

    say "-- Upgrade plan: " . scalar(@plugins) . " plugins, $total_steps steps --";
}

sub _show_plan_refresh ($self, $app) {
    # Phase 1: clean
    my @clean = $self->_collect_clean($app);

    if (@clean) {
        say "-- Clean phase --";
        for my $p (@clean) {
            my $short = $self->_short_name($app, $p->{long_name});
            for my $target (@{ $p->{targets} }) {
                say "   [$short] remove $target";
            }
        }
        say "";
    }

    # Phase 2: init
    $self->_show_plan_init($app);

    say "-- Refresh plan --";
}

sub _run_init ($self, $app) {
    my @plugins = $self->_collect_steps($app, 'fondation_init');

    for my $plugin (@plugins) {
        my $short = $app->manager->registry->{$plugin->{long_name}}{short_name};
        say "-- $short";
        $self->_run_steps($app, 'fondation_init', $plugin->{long_name}, $plugin->{steps});
    }

    say "-- Init complete --";
}

# ---------------------------------------------------------------------------
# fondation upgrade
# ---------------------------------------------------------------------------

sub _run_upgrade ($self, $app) {
    my @plugins = $self->_collect_steps($app, 'fondation_upgrade');

    for my $plugin (@plugins) {
        my $short = $app->manager->registry->{$plugin->{long_name}}{short_name};
        say "-- $short";
        $self->_run_steps($app, 'fondation_upgrade', $plugin->{long_name}, $plugin->{steps});
    }

    say "-- Upgrade complete --";
}

# ---------------------------------------------------------------------------
# fondation refresh
# ---------------------------------------------------------------------------

sub _run_refresh ($self, $app) {
    my $home = $app->home;

    # Phase 1: clean
    my @clean_plugins = $self->_collect_clean($app);

    if (@clean_plugins) {
        say "-- Cleaning generated artifacts --";

        for my $plugin (@clean_plugins) {
            my $short = $app->manager->registry->{$plugin->{long_name}}{short_name};
            for my $target (@{ $plugin->{targets} }) {
                my $path = path($home, $target);

                if (-d $path) {
                    say "   [$short] Removing $target";
                    remove_tree($path->to_string, { safe => 0 });
                }
                elsif (-f $path) {
                    say "   [$short] Removing $target";
                    unlink $path->to_string;
                }
            }
        }
    }

    # Phase 2: init
    $self->_run_init($app);

    say "-- Refresh complete --";
}

1;

__END__