Skilletor/Engine.pm

filter: Statementstmt 84.5% 623 / 737 Branchbran 58.7% 162 / 276 Conditioncond 46.7% 142 / 304 MC/DCmcdc 19.5% 32 / 164 Subroutinesub 91.0% 81 / 89 Podpod 100% 3 / 3 totaltotal 66.3% 1043 / 1573 CC 284 SCAR 34.0
CC
284
Cov
70%
_sync_scope_run
98.4
_tracked_warnings
94.6
status
55.6
CRAP 30.0
« Skilletor/Briefing.pm ↑ Summary Skilletor/Spec.pm »
1 package Skilletor::Engine;
2 # ABSTRACT: sync, check and status for Claude Code – the reference's engine pipeline after the resolve
3  
4 31 ▶use Moo;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 31 ▶use utf8;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 31 ▶use Carp qw( croak );
Subroutine BEGIN: called CC=1 SCAR=0.0
7 31 ▶use Encode ();
Subroutine BEGIN: called CC=1 SCAR=0.0
8 31 ▶use JSON::MaybeXS ();
Subroutine BEGIN: called CC=1 SCAR=0.0
9 31 ▶use Scalar::Util qw( blessed refaddr );
Subroutine BEGIN: called CC=1 SCAR=0.0
10 31 ▶use Skilletor::Apply qw( apply );
Subroutine BEGIN: called CC=1 SCAR=0.0
11 31 ▶use Skilletor::Backend;
Subroutine BEGIN: called CC=1 SCAR=0.0
12 31 ▶use Skilletor::Briefing qw( briefing_warning missing_skills skill_roots );
Subroutine BEGIN: called CC=1 SCAR=0.0
13 31 ▶use Skilletor::Bundles qw( matches_pattern );
Subroutine BEGIN: called CC=1 SCAR=0.0
14 31 ▶use Skilletor::ClaudeSettings qw( plan_claude_settings );
Subroutine BEGIN: called CC=1 SCAR=0.0
15 31 ▶use Skilletor::Config;
Subroutine BEGIN: called CC=1 SCAR=0.0
16 31 ▶use Skilletor::Entry qw( HARNESSES ITEM_TYPES );
Subroutine BEGIN: called CC=1 SCAR=0.0
17 31 ▶use Skilletor::FSUtil qw( encode_text hash_bytes is_absolute path_join path_resolve same_path to_posix write_text );
Subroutine BEGIN: called CC=1 SCAR=0.0
18 31 ▶use Skilletor::Gitignore qw(
Subroutine BEGIN: called CC=1 SCAR=0.0
19 CODEX_ENTRIES LOCAL_ENTRIES PROJECT_CLAUDE_ENTRIES SKILL_GITIGNORE WORKTREE_INCLUDE
20 block_entries has_block skill_gitignore_path update_gitignore update_worktree_include with_skill_gitignore
21 31 );
22 31 ▶use Skilletor::GitEnv qw( git_env );
Subroutine BEGIN: called CC=1 SCAR=0.0
23 31 ▶use Skilletor::JSON qw( js_ordered js_sort_keys js_stringify js_type );
Subroutine BEGIN: called CC=1 SCAR=0.0
24 31 ▶use Skilletor::Lock qw( key_to_type_name parse_lock_key read_lock );
Subroutine BEGIN: called CC=1 SCAR=0.0
25 31 ▶use Skilletor::Process qw( run_command );
Subroutine BEGIN: called CC=1 SCAR=0.0
26 31 ▶use Skilletor::Render qw( build executables templates_of );
Subroutine BEGIN: called CC=1 SCAR=0.0
27 31 ▶use Skilletor::Report qw( empty_scope_report );
Subroutine BEGIN: called CC=1 SCAR=0.0
28 31 ▶use Skilletor::Source::Git;
Subroutine BEGIN: called CC=1 SCAR=0.0
29 31 ▶use Skilletor::Source::Url;
Subroutine BEGIN: called CC=1 SCAR=0.0
30 31 ▶use Skilletor::State;
Subroutine BEGIN: called CC=1 SCAR=0.0
31 31 ▶use Skilletor::Targets qw(
Subroutine BEGIN: called CC=1 SCAR=0.0
32 all_roots default_hermes_home detect_harnesses is_block_type is_local_type lacks_local_prefix lock_key
33 place_output receivers root_of root_of_key select_targets supports target_gaps
34 31 );
35 31 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
36  
37 31 extends 'Skilletor::Resolver';
38  
39 31 our $VERSION = '0.001';
40  
41 # What a sync makes of unchanged sources and inputs (the reference's RENDER_FORMAT, k107): part
42 # of the render-inputs hash, so both implementations record and compare the same one.
43 31 ▶use constant RENDER_FORMAT => 2;
Subroutine BEGIN: called CC=1 SCAR=0.0
44  
45 31 ▶use constant RULES_FILE => 'skilletor-rules.md';
Subroutine BEGIN: called CC=1 SCAR=0.0
46  
47 31 my %TYPE_DIR = ( skill => 'skills', agent => 'agents', rule => 'rules' );
48  
49 # Does a user-scope root lie inside a git work tree (spec §6.4)? Default: ask git.
50 has is_git_work_tree => (
51 is => 'ro',
52 213 ▶ default => sub { \&Skilletor::Gitignore::is_git_work_tree },
Subroutine __ANON__: called CC=1 SCAR=0.0
53 31 );
54  
55 # Which of the paths (relative to a root) does git track? Default: one `git ls-files`.
56 has git_tracked => (
57 is => 'ro',
58 216 ▶ default => sub { \&Skilletor::Gitignore::git_tracked },
Subroutine __ANON__: called CC=1 SCAR=0.0
59 31 );
60  
61 # The project's `origin` remote, a render input of the project scope. Default: ask git.
62 has git_remote => (
63 is => 'ro',
64 263 ▶ default => sub { \&_git_remote },
Subroutine __ANON__: called CC=1 SCAR=0.0
65 31 );
66  
67 # `CLAUDE_PLUGIN_ROOT`: the running plugin's install, naming skilletor's marketplace (spec §6.8).
68 has plugin_root => (
69 is => 'lazy',
70 0 ▶ builder => sub { $ENV{CLAUDE_PLUGIN_ROOT} },
Subroutine _build_plugin_root: not called CC=1 SCAR=6.9
Subroutine __ANON__: not called CC=1 SCAR=6.9
71 31 );
72  
73 0 ▶sub _git_remote {
Subroutine _git_remote: not called CC=5 SCAR=34.0
74 0 my ( $dir ) = @_;
75 0 my $r = eval { run_command( cmd => [ 'git', '-C', $dir, 'remote', 'get-url', 'origin' ], env => git_env() ) };
76 0 ▶ return '' unless $r && !$r->{spawn_error} && defined $r->{code} && $r->{code} == 0;
Branch: 1 branch
BranchTrueFalseTotal
unless $r and not $r->{"spawn_error"} and defined $r->{"code"} and $r->{"code"} == 0 0 0 0
Condition0%0/9
$r and not $r->{"spawn_error"} and defined $r->{"code"} and $r->{"code"} == 0
!ll&&!rl&&r
000
$r and not $r->{"spawn_error"} and defined $r->{"code"}
!ll&&!rl&&r
000
$r and not $r->{"spawn_error"}
!ll&&!rl&&r
000
MC/DC0%0/4
$r and not $r->{"spawn_error"} and defined $r->{"code"} and $r->{"code"} == 0
$r not $r->{"spawn_error"} defined $r->{"code"} $r->{"code"} == 0
Truth table0%0/5
A and not(B) and C and D
A= $rB= not $r->{"spawn_error"}C= defined $r->{"code"}D= $r->{"code"} == 0
ABCDresult
0XXX0
10XX0
110X0
11100
11111
77 0 ( my $out = Encode::decode( 'UTF-8', $r->{stdout} ) ) =~ s/\A\s+|\s+\z//g;
78 0 return $out;
79 }
80  
81 4 ▶sub _message {
Subroutine _message: called CC=3 SCAR=14.2
82 4 my ( $err ) = @_;
83 4 ▶ return $err->message if blessed $err && $err->can('message');
Branch: 1 branch
BranchTrueFalseTotal
if builtin::blessed($err) and $err->can("message") 4 0 4
Condition33%1/3
builtin::blessed($err) and $err->can("message")
!ll&&!rl&&r
004
MC/DC0%0/2
builtin::blessed($err) and $err->can("message")
builtin::blessed($err) $err->can("message")
Truth table33%1/3
A and B
A= builtin::blessed($err)B= $err->can("message")
ABresult
0X0
100
111
84 0 return ( "$err" =~ s/ at \S+ line \d+\.?\n?\z//r =~ s/\n\z//r );
85 }
86  
87 62 ▶sub _true { JSON::MaybeXS::true() }
Subroutine _true: called CC=1 SCAR=0.0
88 25 ▶sub _false { JSON::MaybeXS::false() }
Subroutine _false: called CC=1 SCAR=0.0
89  
90 132 ▶sub _uniq {
Subroutine _uniq: called CC=1 SCAR=0.0
91 132 my %seen;
92 132 return grep { !$seen{$_}++ } @_;
93 }
94  
95 #### Paths ###################################################################
96  
97 # path.relative (posix) of two absolute paths.
98 82 ▶sub _relative {
Subroutine _relative: called CC=4 SCAR=14.0
99 82 my ( $from, $to ) = @_;
100 82 my @f = grep { length } split m{/}, path_resolve($from);
101 82 my @t = grep { length } split m{/}, path_resolve($to);
102 82 ▶ while ( @f && @t && $f[0] eq $t[0] ) { shift @f; shift @t }
Branch: 1 branch
BranchTrueFalseTotal
if (@f and @t and $f[0] eq $t[0]) 267 82 349
Condition66%4/6
@f and @t and $f[0] eq $t[0]
!ll&&!rl&&r
820267
@f and @t
!ll&&!rl&&r
820267
MC/DC33%1/3
@f and @t and $f[0] eq $t[0]
@f @t $f[0] eq $t[0]
Truth table50%2/4
A and B and C
A= @fB= @tC= $f[0] eq $t[0]
ABCresult
0XX0
10X0
1100
1111
103 0 return join '/', ( map {'..'} @f ), @t;
104 }
105  
106 131 ▶sub _codex_home_of {
Subroutine _codex_home_of: called CC=3 SCAR=12.5
107 131 my ( $self ) = @_;
108 131 my $cx = $self->codex_home;
109 131 ▶ return ( defined $cx && length $cx ) ? $cx : undef;
Branch: 1 branch
BranchTrueFalseTotal
defined $cx && length $cx ? : 131 0 131
Condition33%1/3
defined $cx and length $cx
!ll&&!rl&&r
00131
MC/DC0%0/2
defined $cx and length $cx
defined $cx length $cx
Truth table33%1/3
A and B
A= defined $cxB= length $cx
ABresult
0X0
100
111
110 }
111  
112 60 ▶sub _lock_path { my ( $self, $scope ) = @_; return path_join( $self->_target_dir($scope), 'skilletor.lock.json' ) }
Subroutine _lock_path: called CC=1 SCAR=0.0
113  
114 # Where a scope's roots live. Hermes is never a target here: its home is the recorded one.
115 98 ▶sub _root_context {
Subroutine _root_context: called CC=2 SCAR=7.4
116 98 my ( $self, $scope ) = @_;
117 98 my $recorded = eval { Skilletor::State->new( root => $self->state_root )->hermes_home };
118 return {
119 98 ▶ base => $self->_base_of($scope),
Condition33%1/3
$recorded // default_hermes_home($self->home)
l!l&&r!l&&!r
0980
MC/DC0%0/2
$recorded // default_hermes_home($self->home)
$recorded default_hermes_home($self->home)
Truth table33%1/3
A // B
A= $recordedB= default_hermes_home($self->home)
ABresult
1X1
011
000
120 scope => $scope,
121 claude_dir => $self->claude_dir,
122 codex_home => $self->_codex_home_of,
123 hermes_home => $recorded // default_hermes_home( $self->home ),
124 };
125 }
126  
127 # A path for the commit hint and the tracked warning: relative to the project, `~/…` in the user
128 # scope, absolute outside the scope's base.
129 6 ▶sub _scope_label {
Subroutine _scope_label: called CC=4 SCAR=15.6
130 6 my ( $scope, $base, $abs ) = @_;
131 6 my $rel = _relative( $base, $abs );
132 6 ▶ return $abs if $rel =~ /\A\.\./ || is_absolute($rel);
Branch: 1 branch
BranchTrueFalseTotal
if $rel =~ /\A\.\./ or is_absolute($rel) 0 6 6
Condition33%1/3
$rel =~ /\A\.\./ or is_absolute($rel)
l!l&&r!l&&!r
006
MC/DC0%0/2
$rel =~ /\A\.\./ or is_absolute($rel)
$rel =~ /\A\.\./ is_absolute($rel)
Truth table33%1/3
A or B
A= $rel =~ /\A\.\./B= is_absolute($rel)
ABresult
1X1
011
000
133 6 ▶ return $scope eq 'user' ? '~/'.$rel : $rel;
Branch: 1 branch
BranchTrueFalseTotal
$scope eq 'user' ? : 0 6 6
134 }
135  
136 # `s` as one shell word: as is when plain, else single-quoted; a leading `~/` stays unquoted.
137 0 ▶sub _shell_word {
Subroutine _shell_word: not called CC=3 SCAR=24.8
138 0 my ( $s ) = @_;
139 0 ▶ return '~/'._shell_word( substr $s, 2 ) if index( $s, '~/' ) == 0;
Branch: 1 branch
BranchTrueFalseTotal
if index($s, "~/") == 0 0 0 0
140 0 ▶ return $s if $s =~ m{\A[\w./@%+=:,-]+\z}a;
Branch: 1 branch
BranchTrueFalseTotal
if $s =~ m[\A[\w./\@%+=:,-]+\z]a 0 0 0
141 0 return "'".( $s =~ s/'/'\\''/gr )."'";
142 }
143  
144 #### Loading #################################################################
145  
146 # Config and targets as a sync needs them: no harness is a config error.
147 67 ▶sub _load_strict {
Subroutine _load_strict: called CC=2 SCAR=6.9
148 67 my ( $self ) = @_;
149 67 my $config = Skilletor::Config->load( home => $self->home, claude_config_dir => $self->claude_config_dir, project_dir => $self->project_dir_of );
150 67 my $markers = $self->markers;
151 my $targets = select_targets( { user => $config->user->{targets}, project => $config->project ? $config->project->{targets} : undef },
152 67 ▶ detect_harnesses($markers), $markers );
Branch: 1 branch
BranchTrueFalseTotal
$config->project ? : 54 13 67
153 63 return ( $config, $targets );
154 }
155  
156 63 ▶sub _scopes_of {
Subroutine _scopes_of: called CC=7 SCAR=19.9
157 63 my ( $config, $sel ) = @_;
158 63 ▶ croak 'scope must be user, project or all' unless $sel =~ /\A(?:user|project|all)\z/;
Branch: 1 branch
BranchTrueFalseTotal
unless $sel =~ /\A(?:user|project|all)\z/ 0 63 63
159 63 my @scopes;
160 63 ▶ push @scopes, [ user => $config->user ] if $sel eq 'user' || $sel eq 'all';
Branch: 1 branch
BranchTrueFalseTotal
if $sel eq "user" or $sel eq "all" 63 0 63
Condition66%2/3
$sel eq "user" or $sel eq "all"
l!l&&r!l&&!r
33300
MC/DC0%0/2
$sel eq "user" or $sel eq "all"
$sel eq "user" $sel eq "all"
Truth table66%2/3
A or B
A= $sel eq "user"B= $sel eq "all"
ABresult
1X1
011
000
161 63 ▶ push @scopes, [ project => $config->project ] if ( $sel eq 'project' || $sel eq 'all' ) && $config->project;
Branch: 1 branch
BranchTrueFalseTotal
if $sel eq "project" || $sel eq "all" and $config->project 18 45 63
Condition83%5/6
$sel eq "project" || $sel eq "all" and $config->project
!ll&&!rl&&r
331218
$sel eq "project" or $sel eq "all"
l!l&&r!l&&!r
03033
MC/DC66%2/3
$sel eq "project" || $sel eq "all" and $config->project
$sel eq "project" $sel eq "all" $config->project
Truth table60%3/5
A or B and C
A= $sel eq "project"B= $sel eq "all"C= $config->project
ABCresult
00X0
1X00
0100
1X11
0111
162 63 return @scopes;
163 }
164  
165 # The Perl port installs for Claude Code alone: a scope that targets another harness is refused
166 # whole, before anything is read or written.
167 63 ▶sub _unsupported_targets {
Subroutine _unsupported_targets: called CC=4 SCAR=13.9
168 63 my ( $self, $targets, @scopes ) = @_;
169 63 for my $s (@scopes) {
170 72 my @other = grep { $_ ne 'claude' } @{ $targets->{ $s->[0] } };
171 72 ▶ next unless @other;
Branch: 1 branch
BranchTrueFalseTotal
unless @other 63 9 72
172 9 ▶ my $where = $s->[0] eq 'user' ? '~/.claude/skilletor.json' : q{the project's .claude/skilletor.json or skilletor.local.json};
Branch: 1 branch
BranchTrueFalseTotal
$s->[0] eq 'user' ? : 9 0 9
173 9 return 'the '.$s->[0].' scope targets '.join( ', ', @other ).'; the Perl port of skilletor installs for Claude Code only '
174 .'(set "targets": ["claude"] in '.$where.', or use the skilletor CLI)';
175 }
176 54 return undef;
177 }
178  
179 # What a Claude-only sync would have to leave half done: lock entries of another harness (the
180 # reference removes them from their roots), sections of the Codex rules file, the rules file.
181 31 ▶sub _foreign_state {
Subroutine _foreign_state: called CC=8 SCAR=20.9
182 31 my ( $self, @scopes ) = @_;
183 31 for my $s (@scopes) {
184 34 my $scope = $s->[0];
185 34 my $rc = $self->_root_context($scope);
186 34 my $lock_path = $self->_lock_path($scope);
187 34 ▶ my $lock = eval { read_lock($lock_path) } or next; # unreadable: the scope's sync reports it
Branch: 1 branch
BranchTrueFalseTotal
my $lock = eval { do { read_lock($lock_path) } } or next 34 0 34
188 my @keys = grep {
189 34 my $k = parse_lock_key($_);
190 16 ▶ $lock->{$_}{block} || ( defined $k->{harness} && $k->{harness} ne 'claude' && defined root_of_key( $rc, $_ ) );
Condition77%7/9
$lock->{$_}{'block'} || defined $k->{'harness'} && $k->{'harness'} ne 'claude' && defined root_of_key($rc, $_)
l!l&&r!l&&!r
0313
defined $k->{"harness"} and $k->{"harness"} ne "claude" and defined root_of_key($rc, $_)
!ll&&!rl&&r
1303
defined $k->{"harness"} and $k->{"harness"} ne "claude"
!ll&&!rl&&r
3103
MC/DC50%2/4
$lock->{$_}{'block'} || defined $k->{'harness'} && $k->{'harness'} ne 'claude' && defined root_of_key($rc, $_)
$lock->{$_}{'block'} defined $k->{"harness"} $k->{"harness"} ne "claude" defined root_of_key($rc, $_)
Truth table60%3/5
A || B and C and D
A= $lock->{$_}{'block'}B= defined $k->{"harness"}C= $k->{"harness"} ne "claude"D= defined root_of_key($rc, $_)
ABCDresult
1XXX1
01111
00XX0
010X0
01100
191 } keys %$lock;
192 34 ▶ if (@keys) {
Branch: 1 branch
BranchTrueFalseTotal
if (@keys) 3 31 34
193 3 return $lock_path.' holds items of another harness ('.join( ', ', js_sort_keys(@keys) ).'); the Perl port of skilletor '
194 .'installs for Claude Code only and leaves them to the skilletor CLI (run skilletor sync)';
195 }
196 31 my $rules = path_join( root_of( $rc, 'codex', 'rule' ), RULES_FILE );
197 31 ▶ if ( -e encode_text($rules) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (-e encode_text($rules)) 3 28 31
198 3 return $rules.' exists; the Perl port of skilletor does not maintain the Codex rules file and leaves it to the '
199 .'skilletor CLI (run skilletor sync)';
200 }
201 }
202 25 return undef;
203 }
204  
205 #### Render inputs (spec §5, §14.3, k76) #####################################
206  
207 27 ▶sub _render_inputs_of {
Subroutine _render_inputs_of: called CC=2 SCAR=10.1
208 27 my ( $self, $scope, $scope_cfg ) = @_;
209 27 ▶ return { vars => $scope_cfg->{vars} } unless $scope eq 'project';
Branch: 1 branch
BranchTrueFalseTotal
unless $scope eq "project" 27 0 27
210 0 my $dir = $self->project_dir_of;
211 0 ( my $name = $dir ) =~ s{\A.*/}{};
212 0 return { vars => $scope_cfg->{vars}, project => { dir => $dir, name => $name, git_remote => $self->git_remote->($dir) } };
213 }
214  
215 # The value as JSON with every object's keys sorted: key order in a config file is no change.
216 84 ▶sub _canonical_json {
Subroutine _canonical_json: called CC=3 SCAR=11.1
217 84 my ( $v ) = @_;
218 84 my $type = js_type($v);
219 0 ▶ return '['.join( ',', map { _canonical_json($_) } @$v ).']' if $type eq 'array';
Branch: 1 branch
BranchTrueFalseTotal
if $type eq "array" 0 84 84
220 84 ▶ if ( $type eq 'object' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($type eq "object") 54 30 84
221 54 return '{'.join( ',', map { js_stringify("$_").':'._canonical_json( $v->{$_} ) } js_sort_keys( keys %$v ) ).'}';
222 }
223 30 return js_stringify($v);
224 }
225  
226 27 ▶sub _render_inputs_hash {
Subroutine _render_inputs_hash: called CC=1 SCAR=0.0
227 27 my ( $inputs ) = @_;
228 27 return hash_bytes( encode_text( _canonical_json( { format => 0 + RENDER_FORMAT, %$inputs } ) ) );
229 }
230  
231 59 ▶sub _scope_sources {
Subroutine _scope_sources: called CC=1 SCAR=0.0
232 59 my ( $scope_cfg ) = @_;
233 59 return _uniq( map { $_->{source} } @{ $scope_cfg->{install} }, @{ $scope_cfg->{wildcards} }, @{ $scope_cfg->{bundles} } );
234 }
235  
236 # The sources a scope renders items from: those it declares, and those its lock holds entries of.
237 36 ▶sub _render_sources {
Subroutine _render_sources: called CC=1 SCAR=0.0
238 36 my ( $scope_cfg, $lock ) = @_;
239 36 return _uniq( _scope_sources($scope_cfg), map { $lock->{$_}{source} } keys %$lock );
240 }
241  
242 14 ▶sub _source_read {
Subroutine _source_read: called CC=3 SCAR=11.3
243 14 my ( $backend, $version ) = @_;
244 14 my $read = { kind => $backend->{kind}, address => $backend->{address}, version => $version };
245 14 ▶ $read->{ref} = $backend->{ref} if defined $backend->{ref};
Branch: 1 branch
BranchTrueFalseTotal
if defined $backend->{"ref"} 0 14 14
246 14 ▶ $read->{path} = $backend->{path} if defined $backend->{path};
Branch: 1 branch
BranchTrueFalseTotal
if defined $backend->{"path"} 0 14 14
247 14 return $read;
248 }
249  
250 9 ▶sub _source_version {
Subroutine _source_version: called CC=4 SCAR=16.9
251 9 my ( $lock, $name ) = @_;
252 9 ▶ for my $e ( values %$lock ) { return $e->{version} if defined $e->{source} && $e->{source} eq $name }
Branch: 1 branch
BranchTrueFalseTotal
if defined $e->{"source"} and $e->{"source"} eq $name 9 0 9
Condition33%1/3
defined $e->{"source"} and $e->{"source"} eq $name
!ll&&!rl&&r
009
MC/DC0%0/2
defined $e->{"source"} and $e->{"source"} eq $name
defined $e->{"source"} $e->{"source"} eq $name
Truth table33%1/3
A and B
A= defined $e->{"source"}B= $e->{"source"} eq $name
ABresult
0X0
100
111
253 0 return undef;
254 }
255  
256 # The version `check` compares a source with: the one the last sync read through this very
257 # backend (kind, address, ref, path); with no record, the lock's.
258 13 ▶sub _checked_version {
Subroutine _checked_version: called CC=8 SCAR=25.7
259 13 my ( $read, $backend, $lock, $name ) = @_;
260 13 ▶ return _source_version( $lock, $name ) unless $read;
Branch: 1 branch
BranchTrueFalseTotal
unless $read 9 4 13
261 my $same = $read->{kind} eq $backend->{kind} && $read->{address} eq $backend->{address}
262 && ( $read->{ref} // "\0" ) eq ( $backend->{ref} // "\0" )
263 4 ▶ && js_stringify( $read->{path} ) eq js_stringify( $backend->{path} );
Condition38%5/13
$read->{'kind'} eq $backend->{'kind'} && $read->{'address'} eq $backend->{'address'} && ($read->{'ref'} // "\000") eq ($backend->{'ref'} // "\000") && js_stringify($read->{'path'}) eq js_stringify($backend->{'path'})
!ll&&!rl&&r
004
$read->{"kind"} eq $backend->{"kind"} and $read->{"address"} eq $backend->{"address"} and ($read->{"ref"} // "\0") eq ($backend->{"ref"} // "\0")
!ll&&!rl&&r
004
$read->{"kind"} eq $backend->{"kind"} and $read->{"address"} eq $backend->{"address"}
!ll&&!rl&&r
004
$read->{"ref"} // "\0"
l!l
04
$backend->{"ref"} // "\0"
l!l
04
MC/DC0%0/4
$read->{'kind'} eq $backend->{'kind'} && $read->{'address'} eq $backend->{'address'} && ($read->{'ref'} // "\000") eq ($backend->{'ref'} // "\000") && js_stringify($read->{'path'}) eq js_stringify($backend->{'path'})
$read->{"kind"} eq $backend->{"kind"} $read->{"address"} eq $backend->{"address"} $read->{"ref"} js_stringify($read->{'path'}) eq js_stringify($backend->{'path'})
MC/DC0%0/1
$backend->{"ref"} // "\0"
$backend->{"ref"}
Truth table0%0/5
A and B and C && D
A= $read->{"kind"} eq $backend->{"kind"}B= $read->{"address"} eq $backend->{"address"}C= $read->{"ref"}D= js_stringify($read->{'path'}) eq js_stringify($backend->{'path'})
ABCDresult
0XXX0
10XX0
110X0
11100
11111
Truth table50%1/2
A
A= $backend->{"ref"}
Aresult
11
00
264 4 ▶ return $same ? $read->{version} : undef;
Branch: 1 branch
BranchTrueFalseTotal
$same ? : 4 0 4
265 }
266  
267 #### sync ####################################################################
268  
269 37 ▶sub sync {
Subroutine sync: called CC=2 SCAR=6.9
Pod documented
270 37 my ( $self, %opts ) = @_;
271 37 ▶ my $sel = $opts{scope} // 'all';
Condition100%2/2
$opts{"scope"} // "all"
l!l
1522
MC/DC100%1/1
$opts{"scope"} // "all"
$opts{"scope"}
Truth table100%2/2
A
A= $opts{"scope"}
Aresult
11
00
272 37 my $state = Skilletor::State->new( root => $self->state_root );
273 my $report = $state->with_lock(
274 37 ▶ sub {
Subroutine __ANON__: called CC=7 SCAR=19.5
275 37 Skilletor::Source::Url->sweep_cache( $self->cache_root );
276 37 Skilletor::Source::Git->sweep_cache( $self->cache_root );
277 37 my ( $config, $targets );
278 37 ▶ return { scopes => [], error => _message($@) } unless eval { ( $config, $targets ) = $self->_load_strict; 1 };
Branch: 1 branch
BranchTrueFalseTotal
unless eval { do { () = $self->_load_strict; 1 } } 3 34 37
279 34 my @scopes = _scopes_of( $config, $sel );
280 34 ▶ if ( defined( my $why = $self->_unsupported_targets( $targets, @scopes ) // $self->_foreign_state(@scopes) ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $why = $self->_unsupported_targets($targets, @scopes) // $self->_foreign_state(@scopes))) 9 25 34
Condition100%3/3
$self->_unsupported_targets($targets, @scopes) // $self->_foreign_state(@scopes)
l!l&&r!l&&!r
3625
MC/DC100%2/2
$self->_unsupported_targets($targets, @scopes) // $self->_foreign_state(@scopes)
$self->_unsupported_targets($targets, @scopes) $self->_foreign_state(@scopes)
Truth table100%3/3
A // B
A= $self->_unsupported_targets($targets, @scopes)B= $self->_foreign_state(@scopes)
ABresult
1X1
011
000
281 9 return { scopes => [], error => $why };
282 }
283 25 my $run = {};
284 25 my $out = { scopes => [] };
285 25 for my $s (@scopes) {
286 28 my ( $scope, $scope_cfg ) = @$s;
287 28 my $rep = $self->_sync_scope( $config, $scope_cfg, $scope, $targets->{$scope}, \%opts, $state, $run );
288 # The Hermes home record lives while Hermes is a target; it never is here.
289 23 ▶ $state->put_hermes_home(undef) if $scope eq 'user';
Branch: 1 branch
BranchTrueFalseTotal
if $scope eq "user" 20 3 23
290 23 ▶ unshift @{ $rep->{warnings} }, @{ $targets->{warnings} } if $scope eq 'project';
Branch: 1 branch
BranchTrueFalseTotal
if $scope eq "project" 3 20 23
291 23 push @{ $out->{scopes} }, $rep;
292 }
293 20 return $out;
294 },
295 37 timeout_ms => $self->lock_timeout_ms,
296 );
297 32 return $report;
298 }
299  
300 # A sync that stops with an error may have changed the lock (a partial entry): the scope's
301 # records no longer hold and are cleared, so `check` counts everything again.
302 28 ▶sub _sync_scope {
Subroutine _sync_scope: called CC=2 SCAR=6.9
303 28 my ( $self, @args ) = @_;
304 28 my $rep;
305 28 ▶ return $rep if eval { $rep = $self->_sync_scope_run(@args); 1 };
Branch: 1 branch
BranchTrueFalseTotal
if eval { do { $rep = $self->_sync_scope_run(@args); 1 } } 23 3 26
306 3 my $err = $@;
307 3 my ( $scope, $state ) = @args[ 2, 5 ];
308 3 eval {
309 3 my $lock_path = $self->_lock_path($scope);
310 3 $state->put_unreached( $lock_path, [] );
311 3 $state->put_sources_read( $lock_path, {} );
312 3 $state->put_render_inputs( $lock_path, undef );
313 3 1;
314 };
315 3 die $err;
316 }
317  
318 28 ▶sub _sync_scope_run {
Subroutine _sync_scope_run: called CC=39 SCAR=45.9
319 28 my ( $self, $config, $scope_cfg, $scope, $harnesses, $opts, $state, $run ) = @_;
320 28 my $target_dir = $self->_target_dir($scope);
321 28 my $base = $self->_base_of($scope);
322 28 my $rc = $self->_root_context($scope);
323 28 my $lock_path = path_join( $target_dir, 'skilletor.lock.json' );
324 28 my $old_lock = read_lock($lock_path);
325 28 ▶ my $gitignore_on = $scope_cfg->{gitignore} ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$scope_cfg->{'gitignore'} ? : 28 0 28
326 28 my $inputs;
327 28 ▶ my $inputs_of = sub { $inputs //= $self->_render_inputs_of( $scope, $scope_cfg ) };
Subroutine __ANON__: called CC=2 SCAR=8.1
Condition33%1/3
$inputs //= $self->_render_inputs_of($scope, $scope_cfg)
l!l&&r!l&&!r
0140
MC/DC0%0/2
$inputs //= $self->_render_inputs_of($scope, $scope_cfg)
$inputs $self->_render_inputs_of($scope, $scope_cfg)
Truth table33%1/3
A //= B
A= $inputsB= $self->_render_inputs_of($scope, $scope_cfg)
ABresult
1X1
011
000
328  
329 28 my @plan;
330 # Entries this version cannot place (an unknown harness prefix) are never touched.
331 28 my @keep = grep { !defined root_of_key( $rc, $_ ) } keys %$old_lock;
332 28 my %key_info;
333 my %held_back; # sources with an item the Perl port does not build (templates)
334 28 ▶ my $receivers_of = sub { @{ receivers( $harnesses, $_[0], $scope ) } };
Subroutine __ANON__: called CC=1 SCAR=0.0
335 my $hooks = {
336 0 ▶ keep => sub {
Subroutine __ANON__: not called CC=3 SCAR=24.8
337 0 my ( $target, $type ) = @_;
338 0 for my $h ( $receivers_of->($type) ) {
339 0 my $key = lock_key( $h, $target );
340 0 ▶ push @keep, $key if exists $old_lock->{$key};
Branch: 1 branch
BranchTrueFalseTotal
if exists $old_lock->{$key} 0 0 0
341 }
342 },
343 37 ▶ declare => sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
344 37 my ( $item ) = @_;
345 37 my @targets = $receivers_of->( $item->{type} );
346 37 ▶ return 0 unless @targets;
Branch: 1 branch
BranchTrueFalseTotal
unless @targets 0 37 37
347 37 for my $h (@targets) {
348 37 my $key = lock_key( $h, $item->{target} );
349 37 $key_info{$key} = { key => $key, type => $item->{type}, name => $item->{name}, source => $item->{source} };
350 }
351 37 return 1;
352 },
353 37 ▶ build => sub {
Subroutine __ANON__: called CC=15 SCAR=29.1
354 37 my ( $item, $extra, $found, $warnings ) = @_;
355 37 my ( $r, $cat, $ci ) = @{$found}{qw( r cat item )};
356 37 for my $h ( $receivers_of->( $item->{type} ) ) {
357 37 my $key = lock_key( $h, $item->{target} );
358 37 ▶ if ( my @tpl = templates_of($ci) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (my(@tpl) = templates_of($ci)) 6 31 37
359 # The Perl port renders no Nunjucks: the item stays as it is installed, as for an
360 # unreachable source, and its source counts as not reached for the records.
361 6 push @$warnings, $item->{type}.' '.$item->{name}.'@'.$item->{source}.' is a Nunjucks template ('.join( ', ', @tpl )
362 .') the Perl port of skilletor does not render; an installed copy stays';
363 6 ▶ push @keep, $key if exists $old_lock->{$key};
Branch: 1 branch
BranchTrueFalseTotal
if exists $old_lock->{$key} 3 3 6
364 6 $held_back{ $item->{source} } = 1;
365 6 next;
366 }
367 31 my ( $output, $executable );
368 31 my $ok = eval {
369 31 $output = build( $ci, $r->{dir} );
370 # A skill's scripts keep their source's executable bit (k99); an agent or rule never.
371 31 ▶ $executable = $item->{type} eq 'skill' ? executables( $ci, $r->{dir} ) : {};
Branch: 1 branch
BranchTrueFalseTotal
$item->{'type'} eq 'skill' ? : 28 3 31
372 31 1;
373 };
374 31 ▶ unless ($ok) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($ok) 0 31 31
375 0 ▶ my $where = @$harnesses > 1 ? ' ('.$h.')' : '';
Branch: 1 branch
BranchTrueFalseTotal
@$harnesses > 1 ? : 0 0 0
376 0 push @$warnings, 'template error in '.$item->{type}.' '.$item->{name}.$where.': '._message($@);
377 0 ▶ push @keep, $key if exists $old_lock->{$key};
Branch: 1 branch
BranchTrueFalseTotal
if exists $old_lock->{$key} 0 0 0
378 0 next;
379 }
380 31 my $p = { key => $key, type => $item->{type}, name => $item->{name}, source => $item->{source}, version => $r->{version} };
381 31 ▶ $p->{via} = $extra->{via} if $extra->{via} && @{ $extra->{via} };
Branch: 1 branch
BranchTrueFalseTotal
if $extra->{"via"} and @{$extra->{"via"};} 0 31 31
Condition33%1/3
$extra->{"via"} and @{$extra->{"via"};}
!ll&&!rl&&r
0310
MC/DC0%0/2
$extra->{"via"} and @{$extra->{"via"};}
$extra->{"via"} @{$extra->{"via"};}
Truth table33%1/3
A and B
A= $extra->{"via"}B= @{$extra->{"via"};}
ABresult
0X0
100
111
382 31 ▶ $p->{inBlock} = 1 if is_block_type( $h, $item->{type} );
Branch: 1 branch
BranchTrueFalseTotal
if is_block_type($h, $item->{"type"}) 0 31 31
383 # Layout names (spec §6.3, §6.4): `.local.` agents and rules claiming their plain path; a
384 # skill carries its own `.gitignore` while the scope's switch is on.
385 31 my $placed = place_output( $h, $item->{type}, $output );
386 31 $p->{output} = $placed->{output};
387 31 ▶ $p->{claims} = $placed->{claims} if @{ $placed->{claims} };
Branch: 1 branch
BranchTrueFalseTotal
if @{$placed->{"claims"};} 3 28 31
388 31 ▶ if ( $item->{type} eq 'skill' && $gitignore_on ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($item->{"type"} eq "skill" and $gitignore_on) 28 3 31
Condition66%2/3
$item->{"type"} eq "skill" and $gitignore_on
!ll&&!rl&&r
3028
MC/DC50%1/2
$item->{"type"} eq "skill" and $gitignore_on
$item->{"type"} eq "skill" $gitignore_on
Truth table66%2/3
A and B
A= $item->{"type"} eq "skill"B= $gitignore_on
ABresult
0X0
100
111
389 28 $p->{output} = with_skill_gitignore( $p->{output}, $item->{name} );
390 28 delete $executable->{ skill_gitignore_path( $item->{name} ) }; # skilletor's own, not the source's
391 }
392 31 ▶ $p->{executable} = $executable if %$executable;
Branch: 1 branch
BranchTrueFalseTotal
if %$executable 0 31 31
393 31 push @plan, $p;
394 }
395 },
396 28 };
397  
398 28 my ( $rep, $info ) = $self->_resolve_scope( $config, $scope_cfg, $scope, $state, $run, $hooks );
399 28 undef $hooks;
400 28 my $out = empty_scope_report($scope);
401 28 $out->{warnings} = $rep->{warnings};
402 28 $out->{trustRequests} = $rep->{trustRequests};
403 28 my $warnings = $out->{warnings};
404 0 ▶ my $label_of = sub {
Subroutine __ANON__: not called CC=3 SCAR=24.8
405 0 my ( $abs ) = @_;
406 0 my $rel = _relative( $base, $abs );
407 0 ▶ return ( $rel =~ /\A\.\./ || is_absolute($rel) ) ? $abs : to_posix($rel);
Branch: 1 branch
BranchTrueFalseTotal
$rel =~ /\A\.\./ || is_absolute($rel) ? : 0 0 0
Condition0%0/3
$rel =~ /\A\.\./ or is_absolute($rel)
l!l&&r!l&&!r
000
MC/DC0%0/2
$rel =~ /\A\.\./ or is_absolute($rel)
$rel =~ /\A\.\./ is_absolute($rel)
Truth table0%0/3
A or B
A= $rel =~ /\A\.\./B= is_absolute($rel)
ABresult
1X1
011
000
408 28 };
409  
410 my $result = apply(
411 \@plan,
412 target_dir => $target_dir,
413 force => $opts->{force},
414 keep => \@keep,
415 31 ▶ root_of => sub { root_of_key( $rc, $_[0] ) // $target_dir },
Subroutine __ANON__: called CC=2 SCAR=9.2
Condition33%1/3
root_of_key($rc, $_[0]) // $target_dir
l!l&&r!l&&!r
3100
MC/DC0%0/2
root_of_key($rc, $_[0]) // $target_dir
root_of_key($rc, $_[0]) $target_dir
Truth table33%1/3
A // B
A= root_of_key($rc, $_[0])B= $target_dir
ABresult
1X1
011
000
416 28 );
417  
418 {
419 # One block of fixed entries per target root (spec §6.4): `.claude/.gitignore` while the
420 # scope is in use; a block found in another root goes. User roots get one only inside a git
421 # work tree.
422 25 my $new_lock = read_lock($lock_path);
423 25 ▶ my $in_use = $scope eq 'user' || _project_in_use( $target_dir, $new_lock );
Condition66%2/3
$scope eq 'user' || _project_in_use($target_dir, $new_lock)
l!l&&r!l&&!r
2230
MC/DC0%0/2
$scope eq 'user' || _project_in_use($target_dir, $new_lock)
$scope eq 'user' _project_in_use($target_dir, $new_lock)
Truth table66%2/3
A || B
A= $scope eq 'user'B= _project_in_use($target_dir, $new_lock)
ABresult
1X1
011
000
424 25 my $codex_root = root_of( $rc, 'codex', 'rule' );
425 25 ▶ my $holds_managed = sub {
Subroutine __ANON__: called CC=5 SCAR=17.0
426 25 my ( $root ) = @_;
427 return grep {
428 25 my $e = $new_lock->{$_};
429 31 ▶ !$e->{block} && %{ $e->{files} // {} } && ( root_of_key( $rc, $_ ) // '' ) eq $root;
Condition60%6/10
!$e->{'block'} && %{$e->{'files'} // {};} && (root_of_key($rc, $_) // '') eq $root
!ll&&!rl&&r
3280
not $e->{"block"} and %{$e->{"files"} // {};}
!ll&&!rl&&r
0328
$e->{"files"} // {}
l!l
310
root_of_key($rc, $_) // ""
l!l
280
MC/DC33%1/3
!$e->{'block'} && %{$e->{'files'} // {};} && (root_of_key($rc, $_) // '') eq $root
not $e->{"block"} %{$e->{"files"} // {};} root_of_key($rc, $_)
MC/DC0%0/1
$e->{"files"} // {}
$e->{"files"}
Truth table50%2/4
not(A) and B && C
A= not $e->{"block"}B= %{$e->{"files"} // {};}C= root_of_key($rc, $_)
ABCresult
0XX0
10X0
1100
1111
Truth table50%1/2
A
A= $e->{"files"}
Aresult
11
00
430 } keys %$new_lock;
431 25 };
432 25 for my $root ( all_roots($rc) ) {
433 75 my @entries;
434 75 ▶ if ( $in_use && $root eq $target_dir ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($in_use and $root eq $target_dir) { } 25 50 75
elsif ($in_use and $root eq $codex_root and &$holds_managed($root)) { } 0 75 75
Condition66%2/3
$in_use and $root eq $target_dir
!ll&&!rl&&r
05025
MC/DC50%1/2
$in_use and $root eq $target_dir
$in_use $root eq $target_dir
Truth table66%2/3
A and B
A= $in_useB= $root eq $target_dir
ABresult
0X0
100
111
435 25 ▶ @entries = $scope eq 'project' ? PROJECT_CLAUDE_ENTRIES : $self->_user_claude_entries($target_dir);
Branch: 1 branch
BranchTrueFalseTotal
$scope eq 'project' ? : 3 22 25
436 }
437 ▶ elsif ( $in_use && $root eq $codex_root && $holds_managed->($root) ) {
Condition66%4/6
$in_use and $root eq $codex_root and &$holds_managed($root)
!ll&&!rl&&r
25250
$in_use and $root eq $codex_root
!ll&&!rl&&r
02525
MC/DC0%0/3
$in_use and $root eq $codex_root and &$holds_managed($root)
$in_use $root eq $codex_root &$holds_managed($root)
Truth table50%2/4
A and B and C
A= $in_useB= $root eq $codex_rootC= &$holds_managed($root)
ABCresult
0XX0
10X0
1100
1111
438 0 @entries = CODEX_ENTRIES;
439 }
440 75 ▶ my $enabled = $gitignore_on && @entries && ( $scope eq 'project' || $self->_in_work_tree($root) );
Condition77%7/9
$gitignore_on && @entries && ($scope eq 'project' || $self->_in_work_tree($root))
!ll&&!rl&&r
50223
$gitignore_on and @entries
!ll&&!rl&&r
05025
$scope eq "project" or $self->_in_work_tree($root)
l!l&&r!l&&!r
3022
MC/DC50%2/4
$gitignore_on && @entries && ($scope eq 'project' || $self->_in_work_tree($root))
$gitignore_on @entries $scope eq "project" $self->_in_work_tree($root)
Truth table60%3/5
A and B && C or D
A= $gitignore_onB= @entriesC= $scope eq "project"D= $self->_in_work_tree($root)
ABCDresult
0XXX0
10XX0
11000
111X1
11011
441 75 my $change = update_gitignore( dir => $root, entries => \@entries, enabled => $enabled );
442 75 ▶ push @{ $out->{gitignoreUpdated} }, _scope_label( $scope, $base, path_join( $root, '.gitignore' ) )
Branch: 1 branch
BranchTrueFalseTotal
if $change eq "created" or $change eq "changed" 3 72 75
Condition66%2/3
$change eq "created" or $change eq "changed"
l!l&&r!l&&!r
3072
MC/DC50%1/2
$change eq "created" or $change eq "changed"
$change eq "created" $change eq "changed"
Truth table66%2/3
A or B
A= $change eq "created"B= $change eq "changed"
ABresult
1X1
011
000
443 if $change eq 'created' || $change eq 'changed';
444 }
445 # The project's `.worktreeinclude` (spec §6.4, k124), written while the project is in use.
446 25 ▶ if ( $scope eq 'project' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($scope eq "project") 3 22 25
447 3 my $change;
448 3 ▶ if ( eval { $change = update_worktree_include( dir => $base, entries => [ $self->_worktree_include_entries($rc) ], enabled => $gitignore_on && $in_use ); 1 } ) {
Branch: 1 branch
BranchTrueFalseTotal
if (eval { do { $change = update_worktree_include('dir', $base, 'entries', [$self->_worktree_include_entries($rc)], 'enabled', $gitignore_on && $in_use); 1 } }) { } 3 0 3
Condition33%1/3
$gitignore_on && $in_use
!ll&&!rl&&r
003
MC/DC0%0/2
$gitignore_on && $in_use
$gitignore_on $in_use
Truth table33%1/3
A && B
A= $gitignore_onB= $in_use
ABresult
0X0
100
111
449 3 ▶ push @{ $out->{gitignoreUpdated} }, _scope_label( $scope, $base, path_join( $base, WORKTREE_INCLUDE ) )
Branch: 1 branch
BranchTrueFalseTotal
if $change eq "created" or $change eq "changed" 3 0 3
Condition33%1/3
$change eq "created" or $change eq "changed"
l!l&&r!l&&!r
300
MC/DC0%0/2
$change eq "created" or $change eq "changed"
$change eq "created" $change eq "changed"
Truth table33%1/3
A or B
A= $change eq "created"B= $change eq "changed"
ABresult
1X1
011
000
450 if $change eq 'created' || $change eq 'changed';
451 }
452 else {
453 0 push @$warnings, WORKTREE_INCLUDE.' not updated: '._message($@);
454 }
455 }
456 }
457  
458 # The plugin requirement in the committed `.claude/settings.json` (spec §6.8): add-only.
459 25 ▶ if ( my $settings = $self->_claude_settings_plan( $scope, $scope_cfg, $harnesses ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $settings = $self->_claude_settings_plan($scope, $scope_cfg, $harnesses)) 0 25 25
460 0 my $file = $self->_settings_file;
461 0 my $label = _scope_label( $scope, $base, $file );
462 0 push @$warnings, @{ $settings->{warnings} };
463 0 ▶ $out->{settingsSkipped} = [ @{ $settings->{warnings} } ] if @{ $settings->{warnings} };
Branch: 1 branch
BranchTrueFalseTotal
if @{$settings->{"warnings"};} 0 0 0
464 0 ▶ if ( defined $settings->{next} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $settings->{"next"}) 0 0 0
465 0 ▶ if ( eval { write_text( $file, $settings->{next} ); 1 } ) {
Branch: 1 branch
BranchTrueFalseTotal
if (eval { do { write_text($file, $settings->{'next'}); 1 } }) { } 0 0 0
466 0 $out->{settingsUpdated} = { path => $label, enabled => $settings->{enabled}, declared => $settings->{declared} };
467 }
468 else {
469 0 push @$warnings, $label.' not updated: '._message($@);
470 }
471 }
472 }
473  
474 # Managed paths git still tracks (spec §6.4): only what this run wrote or adopted.
475 25 ▶ if ($gitignore_on) {
Branch: 1 branch
BranchTrueFalseTotal
if ($gitignore_on) 25 0 25
476 25 ▶ my @written = map { { root => root_of_key( $rc, $_->{key} ) // $target_dir, key => $_->{key}, path => $_->{path} } } @{ $result->{written} };
Condition33%1/3
root_of_key($rc, $_->{"key"}) // $target_dir
l!l&&r!l&&!r
3400
MC/DC0%0/2
root_of_key($rc, $_->{"key"}) // $target_dir
root_of_key($rc, $_->{"key"}) $target_dir
Truth table33%1/3
A // B
A= root_of_key($rc, $_->{"key"})B= $target_dir
ABresult
1X1
011
000
477 25 push @$warnings, $self->_tracked_warnings( $scope, $base, \@written );
478 }
479  
480 22 ▶ my $to_change = sub {
Subroutine __ANON__: called CC=4 SCAR=21.7
481 22 my ( $key ) = @_;
482 0 ▶ return $key_info{$key} // { key => $key, %{ key_to_type_name($key) }, source => ( $info->{old_lock}{$key} || {} )->{source} // '?' };
Condition16%1/6
$key_info{$key} // {"key", $key, %{key_to_type_name($key);}, "source", +($info->{"old_lock"}{$key} || {})->{"source"} // "?"}
l!l
220
+($info->{"old_lock"}{$key} || {})->{"source"} // "?"
l!l
00
$info->{'old_lock'}{$key} || {}
l!l
00
MC/DC0%0/1
$key_info{$key} // {"key", $key, %{key_to_type_name($key);}, "source", +($info->{"old_lock"}{$key} || {})->{"source"} // "?"}
$key_info{$key}
MC/DC0%0/1
+($info->{"old_lock"}{$key} || {})->{"source"} // "?"
$info->{'old_lock'}{$key}
Truth table50%1/2
A
A= $key_info{$key}
Aresult
11
00
Truth table0%0/2
A
A= $info->{'old_lock'}{$key}
Aresult
11
00
483 23 };
484 23 $out->{$_} = [ map { $to_change->($_) } @{ $result->{$_} } ] for qw( added updated removed unchanged skipped );
485 0 ▶ my $shown = sub {
Subroutine __ANON__: not called CC=3 SCAR=24.8
486 0 my ( $c ) = @_;
487 0 ▶ my $root = root_of_key( $rc, $c->{key} ) // $target_dir;
Condition0%0/3
root_of_key($rc, $c->{"key"}) // $target_dir
l!l&&r!l&&!r
000
MC/DC0%0/2
root_of_key($rc, $c->{"key"}) // $target_dir
root_of_key($rc, $c->{"key"}) $target_dir
Truth table0%0/3
A // B
A= root_of_key($rc, $c->{"key"})B= $target_dir
ABresult
1X1
011
000
488 0 ▶ return $root eq $target_dir ? $c->{path} : $label_of->( path_join( $root, $c->{path} ) );
Branch: 1 branch
BranchTrueFalseTotal
$root eq $target_dir ? : 0 0 0
489 23 };
490 $out->{conflicts} = [
491 map {
492 0 my $c = { path => $shown->($_) };
493 0 ▶ $c->{replace} = $_->{replace} if $_->{replace};
Branch: 1 branch
BranchTrueFalseTotal
if $_->{"replace"} 0 0 0
494 0 ▶ $c->{notFile} = $_->{notFile} if $_->{notFile};
Branch: 1 branch
BranchTrueFalseTotal
if $_->{"notFile"} 0 0 0
495 0 $c;
496 23 } @{ $result->{conflicts} }
497 ];
498 0 $out->{overwritten} = [ map { { path => $shown->($_) } } @{ $result->{overwritten} } ];
499 23 for my $l ( @{ $result->{leftInPlace} } ) {
500 0 push @$warnings, $shown->($l).' is a symbolic link: files of '.$l->{key}.' behind it left in place (never deleted through a link)';
501 }
502  
503 # Briefing check (spec §6.7): every agent the lock holds now, from its installed file.
504 23 my $final_lock = read_lock($lock_path);
505 23 my @briefing = $self->_briefing_of( $scope, $final_lock );
506 23 push @$warnings, briefing_warning( parse_lock_key( $_->{key} )->{name}, $_->{harness}, $_->{missing} ) for @briefing;
507 23 ▶ $out->{briefingMissing} = \@briefing if @briefing;
Branch: 1 branch
BranchTrueFalseTotal
if @briefing 0 23 23
508  
509 # The records `check` compares with (spec §14.3). A source counts as reached when it was
510 # resolved and scanned – and, in the Perl port, when it had no item left unbuilt for being a
511 # template: what the port left alone stays open for the next sync, the reference's included.
512 23 my %resolved = %{ $info->{resolved} };
513 23 my %catalogs = %{ $info->{catalogs} };
514 46 ▶ my $reachable = sub {
Subroutine __ANON__: called CC=5 SCAR=17.5
515 46 my ( $name ) = @_;
516 46 ▶ return 0 unless $resolved{$name};
Branch: 1 branch
BranchTrueFalseTotal
unless $resolved{$name} 0 46 46
517 46 ▶ return 0 if exists $catalogs{$name} && !defined $catalogs{$name};
Branch: 1 branch
BranchTrueFalseTotal
if exists $catalogs{$name} and not defined $catalogs{$name} 0 46 46
Condition33%1/3
exists $catalogs{$name} and not defined $catalogs{$name}
!ll&&!rl&&r
0460
MC/DC0%0/2
exists $catalogs{$name} and not defined $catalogs{$name}
exists $catalogs{$name} not defined $catalogs{$name}
Truth table33%1/3
A and not(B)
A= exists $catalogs{$name}B= not defined $catalogs{$name}
ABresult
0X0
100
111
518 46 ▶ return $held_back{$name} ? 0 : 1;
Branch: 1 branch
BranchTrueFalseTotal
$held_back{$name} ? : 18 28 46
519 23 };
520 23 my @drift = $self->_scope_drift( $scope, $scope_cfg, $harnesses, $final_lock, $info->{served} );
521 0 $state->put_unreached( $lock_path, [ map { $_->{id} } grep { my $d = $_; !grep { !$reachable->($_) } @{ $d->{sources} } } @drift ] );
522 23 my $before = $state->sources_read($lock_path);
523 23 my %read;
524 23 for my $name ( @{ $info->{resolved_order} } ) {
525 20 my $r = $resolved{$name};
526 20 ▶ if ( $r && $reachable->($name) ) { $read{$name} = _source_read( $r->{backend}, $r->{version} ) }
Branch: 2 branches
BranchTrueFalseTotal
if ($r and &$reachable($name)) { } 14 6 20
elsif ($before->{$name}) { } 0 6 6
Condition66%2/3
$r and &$reachable($name)
!ll&&!rl&&r
0614
MC/DC50%1/2
$r and &$reachable($name)
$r &$reachable($name)
Truth table66%2/3
A and B
A= $rB= &$reachable($name)
ABresult
0X0
100
111
527 0 elsif ( $before->{$name} ) { $read{$name} = $before->{$name} }
528 }
529 23 $state->put_sources_read( $lock_path, \%read );
530 0 my %untrusted = map { ( $_->{name} => 1 ) } @{ $out->{trustRequests} };
531 23 ▶ if ( !_render_sources( $scope_cfg, $final_lock ) ) {
Branch: 2 branches
BranchTrueFalseTotal
if (not _render_sources($scope_cfg, $final_lock)) { } 3 20 23
elsif (not grep({not &$reachable($_) || $untrusted{$_};} @{$$info{'resolved_order'};})) { } 14 6 20
532 3 $state->put_render_inputs( $lock_path, undef );
533 }
534 20 ▶ elsif ( !grep { !$reachable->($_) && !$untrusted{$_} } @{ $info->{resolved_order} } ) {
Condition66%2/3
&$reachable($_) || $untrusted{$_}
l!l&&r!l&&!r
1406
MC/DC50%1/2
&$reachable($_) || $untrusted{$_}
&$reachable($_) $untrusted{$_}
Truth table66%2/3
A || B
A= &$reachable($_)B= $untrusted{$_}
ABresult
1X1
011
000
535 14 $state->put_render_inputs( $lock_path, _render_inputs_hash( $inputs_of->() ) );
536 }
537 23 return $out;
538 }
539  
540 22 ▶sub _in_work_tree {
Subroutine _in_work_tree: called CC=2 SCAR=7.0
541 22 my ( $self, $dir ) = @_;
542 22 my $yes = eval { $self->is_git_work_tree->($dir) };
543 22 ▶ return $yes ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$yes ? : 0 22 22
544 }
545  
546 # Entries of the user `~/.claude` block: the lock, the state dir when it lies under `~/.claude`,
547 # the agent and rule patterns. Never `skilletor.json`.
548 22 ▶sub _user_claude_entries {
Subroutine _user_claude_entries: called CC=4 SCAR=16.4
549 22 my ( $self, $claude_dir ) = @_;
550 22 my $rel = _relative( $claude_dir, $self->state_root );
551 22 ▶ my $under = length $rel && $rel !~ /\A\.\./ && !is_absolute($rel);
Condition33%2/6
length $rel && !($rel =~ /\A\.\./) && !is_absolute($rel)
!ll&&!rl&&r
0022
length $rel and not $rel =~ /\A\.\./
!ll&&!rl&&r
0022
MC/DC0%0/3
length $rel && !($rel =~ /\A\.\./) && !is_absolute($rel)
length $rel not $rel =~ /\A\.\./ !is_absolute($rel)
Truth table25%1/4
A and not(B) && not(C)
A= length $relB= not $rel =~ /\A\.\./C= !is_absolute($rel)
ABCresult
0XX0
10X0
1100
1111
552 22 ▶ return ( 'skilletor.lock.json', ( $under ? $rel.'/' : () ), LOCAL_ENTRIES );
Branch: 1 branch
BranchTrueFalseTotal
$under ? : 22 0 22
553 }
554  
555 # Is the project scope in use: a project config file, or lock entries?
556 6 ▶sub _project_in_use {
Subroutine _project_in_use: called CC=3 SCAR=11.4
557 6 my ( $target_dir, $lock ) = @_;
558 6 ▶ return 1 if %$lock;
Branch: 1 branch
BranchTrueFalseTotal
if %$lock 0 6 6
559 6 ▶ return ( grep { -e encode_text( path_join( $target_dir, $_ ) ) } qw( skilletor.json skilletor.local.json ) ) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
grep({-e encode_text(path_join($target_dir, $_));} 'skilletor.json', 'skilletor.local.json') ? : 6 0 6
560 }
561  
562 # The `.worktreeinclude` block of a project (k124): every project root a harness's items go to,
563 # whether or not this machine targets it, the lock and the local config – fixed, sorted.
564 6 ▶sub _worktree_include_entries {
Subroutine _worktree_include_entries: called CC=7 SCAR=19.5
565 6 my ( $self, $rc ) = @_;
566 6 ▶ my $at = sub { '/'.to_posix( _relative( $rc->{base}, $_[0] ) ).( $_[1] // '' ) };
Subroutine __ANON__: called CC=2 SCAR=6.9
Condition100%2/2
$_[1] // ""
l!l
3618
MC/DC100%1/1
$_[1] // ""
$_[1]
Truth table100%2/2
A
A= $_[1]
Aresult
11
00
567 6 my $claude = path_join( $rc->{base}, '.claude' );
568 6 my @out = ( $at->( path_join( $claude, 'skilletor.lock.json' ) ), $at->( path_join( $claude, 'skilletor.local.json' ) ) );
569 6 for my $h (HARNESSES) {
570 18 for my $type (ITEM_TYPES) {
571 54 ▶ my $root = root_of( $rc, $h, $type ) // next;
Condition100%2/2
root_of($rc, $h, $type) // (next)
l!l
4212
MC/DC100%1/1
root_of($rc, $h, $type) // (next)
root_of($rc, $h, $type)
Truth table100%2/2
A
A= root_of($rc, $h, $type)
Aresult
11
00
572 42 ▶ if ( is_block_type( $h, $type ) ) { push @out, $at->( path_join( $root, RULES_FILE ) ) }
Branch: 3 branches
BranchTrueFalseTotal
if (is_block_type($h, $type)) { } 6 36 42
elsif ($type eq 'skill') { } 18 18 36
elsif (is_local_type($h, $type)) { } 18 0 18
573 18 elsif ( $type eq 'skill' ) { push @out, $at->( path_join( $root, 'skills' ), '/' ) }
574 18 elsif ( is_local_type( $h, $type ) ) { push @out, $at->( path_join( $root, $type.'s' ), '/**/.local.*' ) }
575 }
576 }
577 6 return js_sort_keys( _uniq(@out) );
578 }
579  
580 0 ▶sub _settings_file { my ( $self ) = @_; return path_join( $self->_target_dir('project'), 'settings.json' ) }
Subroutine _settings_file: not called CC=1 SCAR=6.9
581  
582 # What a sync adds to the project's `.claude/settings.json` (spec §6.8), or undef when the file is
583 # not skilletor's to touch. Never throws.
584 61 ▶sub _claude_settings_plan {
Subroutine _claude_settings_plan: called CC=9 SCAR=35.7
585 61 my ( $self, $scope, $scope_cfg, $harnesses ) = @_;
586 61 ▶ return undef unless $scope eq 'project';
Branch: 1 branch
BranchTrueFalseTotal
unless $scope eq "project" 55 6 61
587 6 ▶ return undef if js_type( $scope_cfg->{claudeSettings} ) eq 'boolean' && !$scope_cfg->{claudeSettings};
Branch: 1 branch
BranchTrueFalseTotal
if js_type($scope_cfg->{"claudeSettings"}) eq "boolean" and not $scope_cfg->{"claudeSettings"} 0 6 6
Condition33%1/3
js_type($scope_cfg->{"claudeSettings"}) eq "boolean" and not $scope_cfg->{"claudeSettings"}
!ll&&!rl&&r
060
MC/DC0%0/2
js_type($scope_cfg->{"claudeSettings"}) eq "boolean" and not $scope_cfg->{"claudeSettings"}
js_type($scope_cfg->{"claudeSettings"}) eq "boolean" not $scope_cfg->{"claudeSettings"}
Truth table33%1/3
A and not(B)
A= js_type($scope_cfg->{"claudeSettings"}) eq "boolean"B= not $scope_cfg->{"claudeSettings"}
ABresult
0X0
100
111
588 0 ▶ return undef unless grep { $_ eq 'claude' } @$harnesses;
Branch: 1 branch
BranchTrueFalseTotal
unless grep {$_ eq "claude";} @$harnesses 6 0 6
589 0 ▶ return undef unless -e encode_text( path_join( $self->_target_dir($scope), 'skilletor.json' ) );
Branch: 1 branch
BranchTrueFalseTotal
unless -e encode_text(path_join($self->_target_dir($scope), "skilletor.json")) 0 0 0
590 0 my $file = $self->_settings_file;
591 0 my $label = _scope_label( $scope, $self->project_dir_of, $file );
592 0 my $plan = eval {
593 0 ▶ plan_claude_settings(
Branch: 1 branch
BranchTrueFalseTotal
defined $self->plugin_root && length $self->plugin_root ? : 0 0 0
Condition0%0/3
defined $self->plugin_root and length $self->plugin_root
!ll&&!rl&&r
000
MC/DC0%0/2
defined $self->plugin_root and length $self->plugin_root
defined $self->plugin_root length $self->plugin_root
Truth table0%0/3
A and B
A= defined $self->plugin_rootB= length $self->plugin_root
ABresult
0X0
100
111
594 file => $file, label => $label, project_dir => $self->project_dir_of,
595 claude_dir => $self->claude_dir,
596 plugin_root => ( defined $self->plugin_root && length $self->plugin_root ) ? $self->plugin_root : undef,
597 );
598 };
599 0 ▶ return $plan // { enabled => [], declared => [], warnings => [ $label.' not updated: '._message($@) ] };
Condition0%0/2
$plan // {"enabled", [], "declared", [], "warnings", [$label . ' not updated: ' . _message($@)]}
l!l
00
MC/DC0%0/1
$plan // {"enabled", [], "declared", [], "warnings", [$label . ' not updated: ' . _message($@)]}
$plan
Truth table0%0/2
A
A= $plan
Aresult
11
00
600 }
601  
602 # The tracked-file warnings (spec §6.4): of the written and adopted paths, the ones git tracks –
603 # one warning per item with the command that untracks it.
604 25 ▶sub _tracked_warnings {
Subroutine _tracked_warnings: called CC=17 SCAR=45.5
605 25 my ( $self, $scope, $base, $written ) = @_;
606 25 my ( %by_root, @roots );
607 25 for my $w (@$written) {
608 34 ▶ push @roots, $w->{root} unless $by_root{ $w->{root} };
Branch: 1 branch
BranchTrueFalseTotal
unless $by_root{$w->{"root"}} 18 16 34
609 34 push @{ $by_root{ $w->{root} } }, $w;
610 }
611 25 my @out;
612 25 for my $root (@roots) {
613 18 my $list = $by_root{$root};
614 18 ▶ my $tracked = eval { $self->git_tracked->( $root, [ _uniq( map { $_->{path} } @$list ) ] ) } or next;
Branch: 1 branch
BranchTrueFalseTotal
my $tracked = eval { do { $self->git_tracked->($root, [_uniq(map({$_->{"path"};} @$list))]) } } or next 16 0 16
615 0 my %tracked = map { ( $_ => 1 ) } @$tracked;
616 16 my ( %items, @ids );
617 16 for my $w (@$list) {
618 31 ▶ next unless $tracked{ $w->{path} };
Branch: 1 branch
BranchTrueFalseTotal
unless $tracked{$w->{"path"}} 31 0 31
619 0 ▶ my $id = $w->{key} // $w->{path};
Condition0%0/3
$w->{"key"} // $w->{"path"}
l!l&&r!l&&!r
000
MC/DC0%0/2
$w->{"key"} // $w->{"path"}
$w->{"key"} $w->{"path"}
Truth table0%0/3
A // B
A= $w->{"key"}B= $w->{"path"}
ABresult
1X1
011
000
620 0 ▶ push @ids, $id unless $items{$id};
Branch: 1 branch
BranchTrueFalseTotal
unless $items{$id} 0 0 0
621 0 ▶ $items{$id} //= { key => $w->{key}, paths => [] };
Condition0%0/2
$items{$id} //= {"key", $w->{"key"}, "paths", []}
l!l
00
MC/DC0%0/1
$items{$id} //= {"key", $w->{"key"}, "paths", []}
$items{$id}
Truth table0%0/2
A
A= $items{$id}
Aresult
11
00
622 0 push @{ $items{$id}{paths} }, $w->{path};
623 }
624 16 for my $id (@ids) {
625 0 my ( $key, $paths ) = @{ $items{$id} }{qw( key paths )};
626 0 ▶ my $k = defined $key ? parse_lock_key($key) : undef;
Branch: 1 branch
BranchTrueFalseTotal
defined $key ? : 0 0 0
627 0 ▶ my $skill = $k && $k->{type} eq 'skill';
Condition0%0/3
$k && $k->{'type'} eq 'skill'
!ll&&!rl&&r
000
MC/DC0%0/2
$k && $k->{'type'} eq 'skill'
$k $k->{'type'} eq 'skill'
Truth table0%0/3
A && B
A= $kB= $k->{'type'} eq 'skill'
ABresult
0X0
100
111
628 0 ▶ my @targets = $skill ? ( $k->{target} ) : @$paths;
Branch: 1 branch
BranchTrueFalseTotal
$skill ? : 0 0 0
629 0 ▶ my $r = $skill ? ' -r' : '';
Branch: 1 branch
BranchTrueFalseTotal
$skill ? : 0 0 0
630 my $cmd = $scope eq 'project'
631 0 ? 'git rm'.$r.' --cached '.join( ' ', map { _shell_word( _scope_label( $scope, $base, path_join( $root, $_ ) ) ) } @targets )
632 0 ▶ : 'git -C '._shell_word( _scope_label( $scope, $base, $root ) ).' rm'.$r.' --cached '.join( ' ', map { _shell_word($_) } @targets );
Branch: 1 branch
BranchTrueFalseTotal
$scope eq 'project' ? : 0 0 0
633 0 ▶ my $label = $key // _scope_label( $scope, $base, path_join( $root, $paths->[0] ) );
Condition0%0/3
$key // _scope_label($scope, $base, path_join($root, $paths->[0]))
l!l&&r!l&&!r
000
MC/DC0%0/2
$key // _scope_label($scope, $base, path_join($root, $paths->[0]))
$key _scope_label($scope, $base, path_join($root, $paths->[0]))
Truth table0%0/3
A // B
A= $keyB= _scope_label($scope, $base, path_join($root, $paths->[0]))
ABresult
1X1
011
000
634 0 push @out, $label.' is tracked by git although skilletor manages it — untrack it: '.$cmd;
635 }
636 }
637 23 return @out;
638 }
639  
640 # Installed agents of a scope's lock whose declared briefing skills do not resolve (spec §6.7).
641 33 ▶sub _briefing_of {
Subroutine _briefing_of: called CC=15 SCAR=29.4
642 33 my ( $self, $scope, $lock, $only ) = @_;
643 33 my $rc = $self->_root_context($scope);
644 33 ▶ my $roots = { home => $self->home, claude_dir => $self->claude_dir, codex_home => $self->_codex_home_of, project_dir => $scope eq 'project' ? $self->project_dir_of : undef };
Branch: 1 branch
BranchTrueFalseTotal
$scope eq 'project' ? : 3 30 33
645 33 my ( %roots_of, @out );
646 33 for my $key ( keys %$lock ) {
647 36 my $entry = $lock->{$key};
648 36 my $k = parse_lock_key($key);
649 36 ▶ next if !defined $k->{harness} || $k->{type} ne 'agent' || $entry->{skipped} || $entry->{block} || ( $only && !$only->{$key} );
Branch: 1 branch
BranchTrueFalseTotal
if not defined $k->{"harness"} or $k->{"type"} ne "agent" or $entry->{"skipped"} or $entry->{"block"} or $only and not $only->{$key} 33 3 36
Condition73%11/15
not defined $k->{"harness"} or $k->{"type"} ne "agent" or $entry->{"skipped"} or $entry->{"block"} or $only and not $only->{$key}
l!l&&r!l&&!r
3303
not defined $k->{"harness"} or $k->{"type"} ne "agent" or $entry->{"skipped"} or $entry->{"block"}
l!l&&r!l&&!r
3303
not defined $k->{"harness"} or $k->{"type"} ne "agent" or $entry->{"skipped"}
l!l&&r!l&&!r
3303
not defined $k->{"harness"} or $k->{"type"} ne "agent"
l!l&&r!l&&!r
3303
$only and not $only->{$key}
!ll&&!rl&&r
210
MC/DC33%2/6
not defined $k->{"harness"} or $k->{"type"} ne "agent" or $entry->{"skipped"} or $entry->{"block"} or $only and not $only->{$key}
not defined $k->{"harness"} $k->{"type"} ne "agent" $entry->{"skipped"} $entry->{"block"} $only not $only->{$key}
Truth table57%4/7
not(A) or B or C or D or E and not(F)
A= not defined $k->{"harness"}B= $k->{"type"} ne "agent"C= $entry->{"skipped"}D= $entry->{"block"}E= $onlyF= not $only->{$key}
ABCDEFresult
1XXXXX1
01XXXX1
001XXX1
0001XX1
0000111
00000X0
0000100
650 3 my $root = root_of_key( $rc, $key );
651 3 ▶ my ($file) = keys %{ $entry->{files} // {} };
Condition50%1/2
$entry->{"files"} // {}
l!l
30
MC/DC0%0/1
$entry->{"files"} // {}
$entry->{"files"}
Truth table50%1/2
A
A= $entry->{"files"}
Aresult
11
00
652 3 ▶ next unless defined $root && defined $file;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $root and defined $file 0 3 3
Condition33%1/3
defined $root and defined $file
!ll&&!rl&&r
003
MC/DC0%0/2
defined $root and defined $file
defined $root defined $file
Truth table33%1/3
A and B
A= defined $rootB= defined $file
ABresult
0X0
100
111
653 3 ▶ $roots_of{ $k->{harness} } //= skill_roots( $k->{harness}, $scope, $roots );
Condition33%1/3
$roots_of{$k->{"harness"}} //= skill_roots($k->{"harness"}, $scope, $roots)
l!l&&r!l&&!r
030
MC/DC0%0/2
$roots_of{$k->{"harness"}} //= skill_roots($k->{"harness"}, $scope, $roots)
$roots_of{$k->{"harness"}} skill_roots($k->{"harness"}, $scope, $roots)
Truth table33%1/3
A //= B
A= $roots_of{$k->{"harness"}}B= skill_roots($k->{"harness"}, $scope, $roots)
ABresult
1X1
011
000
654 3 my $missing = missing_skills( $k->{harness}, path_join( $root, $file ), $roots_of{ $k->{harness} } );
655 3 ▶ push @out, { key => $key, harness => $k->{harness}, missing => $missing } if $missing && @$missing;
Branch: 1 branch
BranchTrueFalseTotal
if $missing and @$missing 0 3 3
Condition33%1/3
$missing and @$missing
!ll&&!rl&&r
030
MC/DC0%0/2
$missing and @$missing
$missing @$missing
Truth table33%1/3
A and B
A= $missingB= @$missing
ABresult
0X0
100
111
656 }
657 33 return @out;
658 }
659  
660 #### Drift (spec §14.3) ######################################################
661  
662 31 my $SKILL_GITIGNORE_HASH = hash_bytes( encode_text(SKILL_GITIGNORE) );
663  
664 # Every drift of a scope: targets, layout, declarations, each { kind, id, sources }.
665 36 ▶sub _scope_drift {
Subroutine _scope_drift: called CC=6 SCAR=19.9
666 36 my ( $self, $scope, $scope_cfg, $harnesses, $lock, $served_by ) = @_;
667 36 my @out;
668 36 for my $g ( @{ target_gaps( [ keys %$lock ], $harnesses, $scope ) } ) {
669 3 my $source = $lock->{ $g->{key} }{source};
670 push @out, defined $g->{missing}
671 ? { kind => 'targets', id => 'missing:'.$g->{missing}.'@'.( $source // 'undefined' ), sources => [$source] }
672 3 ▶ : { kind => 'targets', id => 'orphan:'.$g->{key}, sources => [] };
Branch: 1 branch
BranchTrueFalseTotal
defined $g->{'missing'} ? : 0 3 3
Condition0%0/2
$source // "undefined"
l!l
00
MC/DC0%0/1
$source // "undefined"
$source
Truth table0%0/2
A
A= $source
Aresult
11
00
673 }
674 36 my $settings = $self->_claude_settings_plan( $scope, $scope_cfg, $harnesses );
675 36 ▶ push @out, { kind => 'layout', id => 'layout:claude-settings', sources => [] } if $settings && defined $settings->{next};
Branch: 1 branch
BranchTrueFalseTotal
if $settings and defined $settings->{"next"} 0 36 36
Condition33%1/3
$settings and defined $settings->{"next"}
!ll&&!rl&&r
3600
MC/DC0%0/2
$settings and defined $settings->{"next"}
$settings defined $settings->{"next"}
Truth table33%1/3
A and B
A= $settingsB= defined $settings->{"next"}
ABresult
0X0
100
111
676 36 return ( @out, $self->_layout_drift( $scope, $scope_cfg, $lock ), _declared_drift( $scope_cfg, $scope, $harnesses, $lock, $served_by ) );
677 }
678  
679 36 ▶sub _layout_drift {
Subroutine _layout_drift: called CC=25 SCAR=37.5
680 36 my ( $self, $scope, $scope_cfg, $lock ) = @_;
681 36 ▶ my $gitignore_on = $scope_cfg->{gitignore} ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$scope_cfg->{'gitignore'} ? : 36 0 36
682 36 my @out;
683 36 for my $key ( keys %$lock ) {
684 44 my $entry = $lock->{$key};
685 44 my $k = parse_lock_key($key);
686 44 ▶ my @files = keys %{ $entry->{files} // {} };
Condition50%1/2
$entry->{"files"} // {}
l!l
440
MC/DC0%0/1
$entry->{"files"} // {}
$entry->{"files"}
Truth table50%1/2
A
A= $entry->{"files"}
Aresult
11
00
687 44 ▶ next if !defined $k->{harness} || !supports( $k->{harness}, $k->{type} ) || $entry->{skipped} || $entry->{block} || !@files;
Branch: 1 branch
BranchTrueFalseTotal
if not defined $k->{"harness"} && supports($k->{"harness"}, $k->{"type"}) or $entry->{"skipped"} or $entry->{"block"} or not @files 3 41 44
Condition66%8/12
not defined $k->{"harness"} && supports($k->{"harness"}, $k->{"type"}) or $entry->{"skipped"} or $entry->{"block"} or not @files
l!l&&r!l&&!r
3041
not defined $k->{"harness"} && supports($k->{"harness"}, $k->{"type"}) or $entry->{"skipped"} or $entry->{"block"}
l!l&&r!l&&!r
3041
not defined $k->{"harness"} && supports($k->{"harness"}, $k->{"type"}) or $entry->{"skipped"}
l!l&&r!l&&!r
3041
defined $k->{'harness'} && supports($k->{'harness'}, $k->{'type'})
!ll&&!rl&&r
3041
MC/DC20%1/5
not defined $k->{"harness"} && supports($k->{"harness"}, $k->{"type"}) or $entry->{"skipped"} or $entry->{"block"} or not @files
defined $k->{'harness'} supports($k->{'harness'}, $k->{'type'}) $entry->{"skipped"} $entry->{"block"} not @files
Truth table33%2/6
not(A && B) or C or D or not(E)
A= defined $k->{'harness'}B= supports($k->{'harness'}, $k->{'type'})C= $entry->{"skipped"}D= $entry->{"block"}E= not @files
ABCDEresult
0XXXX1
10XXX1
111XX1
1101X1
110011
110000
688 41 ▶ my $drift = sub { push @out, { kind => 'layout', id => 'layout:'.$key.':'.$_[0], sources => [ $entry->{source} ] } };
Subroutine __ANON__: called CC=1 SCAR=0.0
689 41 ▶ $drift->('local') if lacks_local_prefix( $k->{harness}, $k->{type}, \@files );
Branch: 1 branch
BranchTrueFalseTotal
if lacks_local_prefix($k->{"harness"}, $k->{"type"}, \@files) 0 41 41
690 41 ▶ if ( $k->{type} eq 'skill' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($k->{"type"} eq "skill") 39 2 41
691 39 ▶ my $ours = ( $entry->{files}{ skill_gitignore_path( $k->{name} ) } // '' ) eq $SKILL_GITIGNORE_HASH ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
($entry->{'files'}{skill_gitignore_path($k->{'name'})} // '') eq $SKILL_GITIGNORE_HASH ? : 30 9 39
Condition100%2/2
$entry->{"files"}{skill_gitignore_path($k->{"name"})} // ""
l!l
309
MC/DC100%1/1
$entry->{"files"}{skill_gitignore_path($k->{"name"})} // ""
$entry->{"files"}{skill_gitignore_path($k->{"name"})}
Truth table100%2/2
A
A= $entry->{"files"}{skill_gitignore_path($k->{"name"})}
Aresult
11
00
692 39 ▶ $drift->( $gitignore_on ? 'gitignore' : 'no-gitignore' ) if $ours != $gitignore_on;
Branch: 2 branches
BranchTrueFalseTotal
if $ours != $gitignore_on 9 30 39
$gitignore_on ? : 9 0 9
693 }
694 }
695 36 ▶ my $in_use = $scope eq 'project' && _project_in_use( $self->_target_dir($scope), $lock );
Condition66%2/3
$scope eq 'project' && _project_in_use($self->_target_dir($scope), $lock)
!ll&&!rl&&r
3303
MC/DC50%1/2
$scope eq 'project' && _project_in_use($self->_target_dir($scope), $lock)
$scope eq 'project' _project_in_use($self->_target_dir($scope), $lock)
Truth table66%2/3
A && B
A= $scope eq 'project'B= _project_in_use($self->_target_dir($scope), $lock)
ABresult
0X0
100
111
696 0 ▶ if ( $scope eq 'project' && !$in_use && grep { has_block($_) } all_roots( $self->_root_context($scope) ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($scope eq "project" and not $in_use and grep {has_block($_);} all_roots($self->_root_context($scope))) 0 36 36
Condition50%3/6
$scope eq "project" and not $in_use and grep {has_block($_);} all_roots($self->_root_context($scope))
!ll&&!rl&&r
3600
$scope eq "project" and not $in_use
!ll&&!rl&&r
3330
MC/DC0%0/3
$scope eq "project" and not $in_use and grep {has_block($_);} all_roots($self->_root_context($scope))
$scope eq "project" not $in_use grep {has_block($_);} all_roots($self->_root_context($scope))
Truth table50%2/4
A and not(B) and C
A= $scope eq "project"B= not $in_useC= grep {has_block($_);} all_roots($self->_root_context($scope))
ABCresult
0XX0
10X0
1100
1111
697 0 push @out, { kind => 'layout', id => 'layout:unused-project', sources => [] };
698 }
699 36 ▶ if ( $scope eq 'project' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($scope eq "project") 3 33 36
700 3 my $rc = $self->_root_context($scope);
701 3 ▶ my @want = $gitignore_on && $in_use ? $self->_worktree_include_entries($rc) : ();
Branch: 1 branch
BranchTrueFalseTotal
$gitignore_on && $in_use ? : 3 0 3
Condition33%1/3
$gitignore_on and $in_use
!ll&&!rl&&r
003
MC/DC0%0/2
$gitignore_on and $in_use
$gitignore_on $in_use
Truth table33%1/3
A and B
A= $gitignore_onB= $in_use
ABresult
0X0
100
111
702 3 my @have = block_entries( path_join( $rc->{base}, WORKTREE_INCLUDE ) );
703 3 ▶ if ( join( "\n", @have ) ne join( "\n", @want ) && ( @have || %$lock ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (join("\n", @have) ne join("\n", @want) and @have || %$lock) 0 3 3
Condition16%1/6
join("\n", @have) ne join("\n", @want) and @have || %$lock
!ll&&!rl&&r
300
@have or %$lock
l!l&&r!l&&!r
000
MC/DC0%0/3
join("\n", @have) ne join("\n", @want) and @have || %$lock
join("\n", @have) ne join("\n", @want) @have %$lock
Truth table25%1/4
A and B or C
A= join("\n", @have) ne join("\n", @want)B= @haveC= %$lock
ABCresult
0XX0
1000
11X1
1011
704 0 push @out, { kind => 'layout', id => 'layout:worktreeinclude', sources => [] };
705 }
706 }
707 36 return @out;
708 }
709  
710 # The wildcards and bundles of a scope that declare a lock entry: a bundle its `via` names, a
711 # wildcard of its source and type whose pattern matches its name.
712 38 ▶sub _cover_of {
Subroutine _cover_of: called CC=4 SCAR=23.3
713 38 my ( $scope_cfg, $k, $entry ) = @_;
714 return (
715 0 ( grep { Skilletor::Resolver::_via_has( $entry->{via}, Skilletor::Resolver->bundle_label($_) ) } @{ $scope_cfg->{bundles} } ),
716 0 ▶ ( grep { defined $entry->{source} && $_->{source} eq $entry->{source} && $_->{type} eq $k->{type} && matches_pattern( $_->{pattern}, $k->{name} ) }
Condition0%0/9
defined $entry->{'source'} && $_->{'source'} eq $entry->{'source'} && $_->{'type'} eq $k->{'type'} && matches_pattern($_->{'pattern'}, $k->{'name'})
!ll&&!rl&&r
000
defined $entry->{"source"} and $_->{"source"} eq $entry->{"source"} and $_->{"type"} eq $k->{"type"}
!ll&&!rl&&r
000
defined $entry->{"source"} and $_->{"source"} eq $entry->{"source"}
!ll&&!rl&&r
000
MC/DC0%0/4
defined $entry->{'source'} && $_->{'source'} eq $entry->{'source'} && $_->{'type'} eq $k->{'type'} && matches_pattern($_->{'pattern'}, $k->{'name'})
defined $entry->{"source"} $_->{"source"} eq $entry->{"source"} $_->{"type"} eq $k->{"type"} matches_pattern($_->{'pattern'}, $k->{'name'})
Truth table0%0/5
A and B and C && D
A= defined $entry->{"source"}B= $_->{"source"} eq $entry->{"source"}C= $_->{"type"} eq $k->{"type"}D= matches_pattern($_->{'pattern'}, $k->{'name'})
ABCDresult
0XXX0
10XX0
110X0
11100
11111
717 38 @{ $scope_cfg->{wildcards} } ),
718 );
719 }
720  
721 36 ▶sub _declared_drift {
Subroutine _declared_drift: called CC=19 SCAR=32.5
722 36 my ( $scope_cfg, $scope, $harnesses, $lock, $served_by ) = @_;
723 36 my @out;
724 36 ▶ my $drift = sub { push @out, { kind => 'declared', id => $_[0], sources => $_[1] } };
Subroutine __ANON__: called CC=1 SCAR=0.0
725 36 my %explicit;
726 36 for my $item ( @{ $scope_cfg->{install} } ) {
727 51 $explicit{ $item->{target} } = 1;
728 51 for my $h ( @{ receivers( $harnesses, $item->{type}, $scope ) } ) {
729 51 my $key = lock_key( $h, $item->{target} );
730 51 ▶ my $have = $lock->{$key} ? $lock->{$key}{source} : undef;
Branch: 1 branch
BranchTrueFalseTotal
$lock->{$key} ? : 38 13 51
731 51 ▶ $drift->( 'missing:'.$key.'@'.$item->{source}, [ $item->{source} ] ) unless defined $have && $have eq $item->{source};
Branch: 1 branch
BranchTrueFalseTotal
unless defined $have and $have eq $item->{"source"} 13 38 51
Condition66%2/3
defined $have and $have eq $item->{"source"}
!ll&&!rl&&r
13038
MC/DC50%1/2
defined $have and $have eq $item->{"source"}
defined $have $have eq $item->{"source"}
Truth table66%2/3
A and B
A= defined $haveB= $have eq $item->{"source"}
ABresult
0X0
100
111
732 }
733 }
734 36 my %covered;
735 36 for my $key ( keys %$lock ) {
736 44 my $entry = $lock->{$key};
737 44 my $k = parse_lock_key($key);
738 44 ▶ next unless defined $k->{harness} && grep { $_ eq $k->{harness} } @{ receivers( $harnesses, $k->{type}, $scope ) };
Branch: 1 branch
BranchTrueFalseTotal
unless defined $k->{"harness"} and grep {$_ eq $k->{"harness"};} @{receivers($harnesses, $k->{"type"}, $scope);} 6 38 44
Condition100%3/3
defined $k->{"harness"} and grep {$_ eq $k->{"harness"};} @{receivers($harnesses, $k->{"type"}, $scope);}
!ll&&!rl&&r
3338
MC/DC100%2/2
defined $k->{"harness"} and grep {$_ eq $k->{"harness"};} @{receivers($harnesses, $k->{"type"}, $scope);}
defined $k->{"harness"} grep {$_ eq $k->{"harness"};} @{receivers($harnesses, $k->{"type"}, $scope);}
Truth table100%3/3
A and B
A= defined $k->{"harness"}B= grep {$_ eq $k->{"harness"};} @{receivers($harnesses, $k->{"type"}, $scope);}
ABresult
0X0
100
111
739 38 my @by = _cover_of( $scope_cfg, $k, $entry );
740 38 $covered{ refaddr $_ } = 1 for @by;
741 38 ▶ $drift->( 'orphan:'.$key, [] ) if !@by && !$explicit{ $k->{target} };
Branch: 1 branch
BranchTrueFalseTotal
unless @by or $explicit{$k->{"target"}} 0 38 38
Condition33%1/3
@by or $explicit{$k->{"target"}}
l!l&&r!l&&!r
0380
MC/DC0%0/2
@by or $explicit{$k->{"target"}}
@by $explicit{$k->{"target"}}
Truth table33%1/3
A or B
A= @byB= $explicit{$k->{"target"}}
ABresult
1X1
011
000
742 38 ▶ $drift->( 'partial:'.$key, [ $entry->{source} ] ) if $entry->{partial}; # a sync failed midway (k71)
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"partial"} 3 35 38
743 }
744 36 for my $w ( @{ $scope_cfg->{wildcards} } ) {
745 0 ▶ $drift->( 'wildcard:'.$w->{type}.':'.$w->{raw}, [ $w->{source} ] ) unless $covered{ refaddr $w };
Branch: 1 branch
BranchTrueFalseTotal
unless $covered{builtin::refaddr($w)} 0 0 0
746 }
747 36 for my $b ( @{ $scope_cfg->{bundles} } ) {
748 0 my $label = Skilletor::Resolver->bundle_label($b);
749 0 ▶ $drift->( $label, [ $b->{source}, @{ ( $served_by // {} )->{$label} // [] } ] ) unless $covered{ refaddr $b };
Branch: 1 branch
BranchTrueFalseTotal
unless $covered{builtin::refaddr($b)} 0 0 0
Condition0%0/4
+($served_by // {})->{$label} // []
l!l
00
$served_by // {}
l!l
00
MC/DC0%0/1
+($served_by // {})->{$label} // []
$served_by
Truth table0%0/2
A
A= $served_by
Aresult
11
00
750 }
751 36 return @out;
752 }
753  
754 #### check ###################################################################
755  
756 16 ▶sub check {
Subroutine check: called CC=20 SCAR=32.1
Pod documented
757 16 my ( $self, %opts ) = @_;
758 16 ▶ my $sel = $opts{scope} // 'all';
Condition100%2/2
$opts{"scope"} // "all"
l!l
97
MC/DC100%1/1
$opts{"scope"} // "all"
$opts{"scope"}
Truth table100%2/2
A
A= $opts{"scope"}
Aresult
11
00
759 16 my ( $config, $targets );
760 16 ▶ unless ( eval { ( $config, $targets ) = $self->_load_strict; 1 } ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (eval { do { () = $self->_load_strict; 1 } }) 0 16 16
761 0 return { changed => _false, sources => [], warnings => [], error => _message($@) };
762 }
763 16 my @scopes = _scopes_of( $config, $sel );
764 16 ▶ if ( defined( my $why = $self->_unsupported_targets( $targets, @scopes ) ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $why = $self->_unsupported_targets($targets, @scopes))) 3 13 16
765 3 return { changed => _false, sources => [], warnings => [], error => $why };
766 }
767 13 my $state = Skilletor::State->new( root => $self->state_root );
768 13 my $out = { changed => _false, sources => [], warnings => [] };
769 13 my %field = ( targets => 'targetsChanged', layout => 'layoutChanged', declared => 'declaredChanged' );
770  
771 13 for my $s (@scopes) {
772 13 my ( $scope, $scope_cfg ) = @$s;
773 13 my $lock_path = $self->_lock_path($scope);
774 13 my $old_lock = read_lock($lock_path);
775 13 my %trust;
776 32 ▶ my $trusted = sub {
Subroutine __ANON__: called CC=4 SCAR=14.8
777 32 my ( $name ) = @_;
778 32 ▶ $trust{$name} //= do {
Condition66%2/3
$trust{$name} //= do { my $src = $config->source_of($scope, $name); $src && eval { do { $state->is_trusted($name, "Skilletor::Backend"->resolve($src, $self->home)) } } ? 1 : 0 }
l!l&&r!l&&!r
19130
MC/DC0%0/2
$trust{$name} //= do { my $src = $config->source_of($scope, $name); $src && eval { do { $state->is_trusted($name, "Skilletor::Backend"->resolve($src, $self->home)) } } ? 1 : 0 }
$trust{$name} do { my $src = $config->source_of($scope, $name); $src && eval { do { $state->is_trusted($name, "Skilletor::Backend"->resolve($src, $self->home)) } } ? 1 : 0 }
Truth table66%2/3
A //= B
A= $trust{$name}B= do { my $src = $config->source_of($scope, $name); $src && eval { do { $state->is_trusted($name, "Skilletor::Backend"->resolve($src, $self->home)) } } ? 1 : 0 }
ABresult
1X1
011
000
779 13 my $src = $config->source_of( $scope, $name );
780 13 ▶ ( $src && eval { $state->is_trusted( $name, Skilletor::Backend->resolve( $src, $self->home ) ) } ) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$src && eval { do { $state->is_trusted($name, 'Skilletor::Backend'->resolve($src, $self->home)) } } ? : 13 0 13
Condition33%1/3
$src and eval { do { $state->is_trusted($name, "Skilletor::Backend"->resolve($src, $self->home)) } }
!ll&&!rl&&r
0013
MC/DC0%0/2
$src and eval { do { $state->is_trusted($name, "Skilletor::Backend"->resolve($src, $self->home)) } }
$src eval { do { $state->is_trusted($name, "Skilletor::Backend"->resolve($src, $self->home)) } }
Truth table33%1/3
A and B
A= $srcB= eval { do { $state->is_trusted($name, "Skilletor::Backend"->resolve($src, $self->home)) } }
ABresult
0X0
100
111
781 };
782 32 return $trust{$name};
783 13 };
784 # Drift counts unless the last sync tried it with its sources at hand, or a source it needs
785 # is untrusted – that asks for trust, not for a sync.
786 0 my %unreached = map { ( $_ => 1 ) } @{ $state->unreached($lock_path) };
787 13 my $read = $state->sources_read($lock_path);
788 my @open = grep {
789 22 my $d = $_;
790 22 ▶ !$unreached{ $d->{id} } && !grep { !$trusted->($_) } @{ $d->{sources} };
Condition33%1/3
$unreached{$d->{'id'}} || grep({not &$trusted($_);} @{$$d{'sources'};})
l!l&&r!l&&!r
0022
MC/DC0%0/2
$unreached{$d->{'id'}} || grep({not &$trusted($_);} @{$$d{'sources'};})
$unreached{$d->{'id'}} grep({not &$trusted($_);} @{$$d{'sources'};})
Truth table33%1/3
A || B
A= $unreached{$d->{'id'}}B= grep({not &$trusted($_);} @{$$d{'sources'};})
ABresult
1X1
011
000
791 13 } $self->_scope_drift( $scope, $scope_cfg, $targets->{$scope}, $old_lock );
792 13 for my $kind (qw( targets layout declared )) {
793 39 ▶ next unless grep { $_->{kind} eq $kind } @open;
Branch: 1 branch
BranchTrueFalseTotal
unless grep {$_->{"kind"} eq $kind;} @open 20 19 39
794 19 $out->{changed} = _true;
795 19 push @{ $out->{ $field{$kind} } }, $scope;
796 }
797 # What the last sync rendered with (k76), while a trusted source has items to render.
798 13 ▶ if ( ( grep { $trusted->($_) } _render_sources( $scope_cfg, $old_lock ) )
Branch: 1 branch
BranchTrueFalseTotal
if (grep {&$trusted($_);} _render_sources($scope_cfg, $old_lock) and ($state->render_inputs($lock_path) // "") ne _render_inputs_hash($self->_render_inputs_of($scope, $scope_cfg))) 9 4 13
Condition80%4/5
grep {&$trusted($_);} _render_sources($scope_cfg, $old_lock) and ($state->render_inputs($lock_path) // "") ne _render_inputs_hash($self->_render_inputs_of($scope, $scope_cfg))
!ll&&!rl&&r
049
$state->render_inputs($lock_path) // ""
l!l
49
MC/DC50%1/2
grep {&$trusted($_);} _render_sources($scope_cfg, $old_lock) and ($state->render_inputs($lock_path) // "") ne _render_inputs_hash($self->_render_inputs_of($scope, $scope_cfg))
grep {&$trusted($_);} _render_sources($scope_cfg, $old_lock) $state->render_inputs($lock_path)
Truth table66%2/3
A and B
A= grep {&$trusted($_);} _render_sources($scope_cfg, $old_lock)B= $state->render_inputs($lock_path)
ABresult
0X0
100
111
799 && ( $state->render_inputs($lock_path) // '' ) ne _render_inputs_hash( $self->_render_inputs_of( $scope, $scope_cfg ) ) )
800 {
801 9 $out->{changed} = _true;
802 9 push @{ $out->{varsChanged} }, $scope;
803 }
804 # Sources a bundle pulled items from (spec §15.6) are not declared here; the lock names them.
805 0 ▶ my @via_sources = map { $old_lock->{$_}{source} } grep { my $v = $old_lock->{$_}{via}; ref $v eq 'ARRAY' ? @$v : ( defined $v && length $v ) } keys %$old_lock;
Branch: 1 branch
BranchTrueFalseTotal
ref $v eq 'ARRAY' ? : 0 16 16
Condition33%1/3
defined $v and length $v
!ll&&!rl&&r
1600
MC/DC0%0/2
defined $v and length $v
defined $v length $v
Truth table33%1/3
A and B
A= defined $vB= length $v
ABresult
0X0
100
111
806 13 for my $name ( _uniq( _scope_sources($scope_cfg), @via_sources ) ) {
807 13 ▶ my $src = $config->source_of( $scope, $name ) or next;
Branch: 1 branch
BranchTrueFalseTotal
my $src = $config->source_of($scope, $name) or next 13 0 13
808 13 my $ok = eval {
809 13 my $backend = Skilletor::Backend->resolve( $src, $self->home );
810 13 ▶ if ( !$state->is_trusted( $name, $backend ) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($state->is_trusted($name, $backend)) 0 13 13
811 # Named in every check, as a sync names it (spec §4.3); never fetched.
812 0 push @{ $out->{trustRequests} }, { scope => $scope, %{ Skilletor::Backend->trust_request( $name, $backend ) } };
813 0 return 1;
814 }
815 13 my $version = _checked_version( $read->{$name}, $backend, $old_lock, $name );
816 13 ▶ my $changed = Skilletor::Backend->make( $backend, $self->cache_root, $self->timeout_ms )->check($version) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
'Skilletor::Backend'->make($backend, $self->cache_root, $self->timeout_ms)->check($version) ? : 13 0 13
817 13 ▶ push @{ $out->{sources} }, { name => $name, scope => $scope, changed => $changed ? _true : _false };
Branch: 1 branch
BranchTrueFalseTotal
$changed ? : 13 0 13
818 13 ▶ $out->{changed} = _true if $changed;
Branch: 1 branch
BranchTrueFalseTotal
if $changed 13 0 13
819 13 1;
820 };
821 0 ▶ push @{ $out->{warnings} }, 'source '.$name.': '._message($@) unless $ok;
Branch: 1 branch
BranchTrueFalseTotal
unless $ok 0 13 13
822 }
823 }
824 13 return $out;
825 }
826  
827 #### status ##################################################################
828  
829 14 ▶sub status {
Subroutine status: called CC=31 SCAR=40.2
Pod documented
830 14 my ( $self, %opts ) = @_;
831 14 ▶ my $sel = $opts{scope} // 'all';
Condition100%2/2
$opts{"scope"} // "all"
l!l
95
MC/DC100%1/1
$opts{"scope"} // "all"
$opts{"scope"}
Truth table100%2/2
A
A= $opts{"scope"}
Aresult
11
00
832 14 my ( $config, $targets );
833 14 ▶ return { scopes => [], error => _message($@) } unless eval { ( $config, $targets ) = $self->_load_strict; 1 };
Branch: 1 branch
BranchTrueFalseTotal
unless eval { do { () = $self->_load_strict; 1 } } 1 13 14
834 13 my @scopes = _scopes_of( $config, $sel );
835 13 ▶ if ( defined( my $why = $self->_unsupported_targets( $targets, @scopes ) ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $why = $self->_unsupported_targets($targets, @scopes))) 3 10 13
836 3 return { scopes => [], error => $why };
837 }
838 10 my $state = Skilletor::State->new( root => $self->state_root );
839 10 my $out = { scopes => [] };
840 10 my $given = $self->project_dir;
841 10 ▶ $out->{projectIsHome} = _true if $sel ne 'user' && defined $given && length $given && !defined $self->project_dir_of;
Branch: 1 branch
BranchTrueFalseTotal
if $sel ne "user" and defined $given and length $given and not defined $self->project_dir_of 0 10 10
Condition44%4/9
$sel ne "user" and defined $given and length $given and not defined $self->project_dir_of
!ll&&!rl&&r
1000
$sel ne "user" and defined $given and length $given
!ll&&!rl&&r
1000
$sel ne "user" and defined $given
!ll&&!rl&&r
910
MC/DC0%0/4
$sel ne "user" and defined $given and length $given and not defined $self->project_dir_of
$sel ne "user" defined $given length $given not defined $self->project_dir_of
Truth table40%2/5
A and B and C and not(D)
A= $sel ne "user"B= defined $givenC= length $givenD= not defined $self->project_dir_of
ABCDresult
0XXX0
10XX0
110X0
11100
11111
842  
843 10 for my $s (@scopes) {
844 10 my ( $scope, $scope_cfg ) = @$s;
845 10 my $lock = read_lock( $self->_lock_path($scope) );
846 10 my $active = $targets->{$scope};
847 # One row per declared item and active target that gets a copy of its type.
848 my @rows = map {
849 14 my $i = $_;
850 14 map { { key => lock_key( $_, $i->{target} ), source => $i->{source} } } @{ receivers( $active, $i->{type}, $scope ) };
851 10 } @{ $scope_cfg->{install} };
852 10 my %declared_keys = map { ( $_->{key} => 1 ) } @rows;
853 10 my $versions = js_ordered();
854 10 $versions->{ $lock->{$_}{source} } = $lock->{$_}{version} for grep { defined $lock->{$_}{source} } keys %$lock;
855 10 my @trust;
856 10 for my $name ( _scope_sources($scope_cfg) ) {
857 10 ▶ my $src = $config->source_of( $scope, $name ) or next;
Branch: 1 branch
BranchTrueFalseTotal
my $src = $config->source_of($scope, $name) or next 10 0 10
858 10 my $backend = Skilletor::Backend->resolve( $src, $self->home );
859 10 ▶ push @trust, Skilletor::Backend->trust_request( $name, $backend ) unless $state->is_trusted( $name, $backend );
Branch: 1 branch
BranchTrueFalseTotal
unless $state->is_trusted($name, $backend) 0 10 10
860 }
861 # A skip entry is declared but deliberately not installed.
862 my @declared = map {
863 10 my $entry = $lock->{ $_->{key} };
864 14 ▶ my $d = { key => $_->{key}, source => $_->{source}, installed => ( $entry && !$entry->{skipped} ) ? _true : _false };
Branch: 1 branch
BranchTrueFalseTotal
$entry && !$entry->{'skipped'} ? : 5 9 14
Condition66%2/3
$entry and not $entry->{"skipped"}
!ll&&!rl&&r
905
MC/DC50%1/2
$entry and not $entry->{"skipped"}
$entry not $entry->{"skipped"}
Truth table66%2/3
A and not(B)
A= $entryB= not $entry->{"skipped"}
ABresult
0X0
100
111
865 14 ▶ $d->{skipped} = $entry->{skipped} if $entry && $entry->{skipped};
Branch: 1 branch
BranchTrueFalseTotal
if $entry and $entry->{"skipped"} 0 14 14
Condition66%2/3
$entry and $entry->{"skipped"}
!ll&&!rl&&r
950
MC/DC0%0/2
$entry and $entry->{"skipped"}
$entry $entry->{"skipped"}
Truth table66%2/3
A and B
A= $entryB= $entry->{"skipped"}
ABresult
0X0
100
111
866 14 ▶ $d->{partial} = _true if $entry && $entry->{partial};
Branch: 1 branch
BranchTrueFalseTotal
if $entry and $entry->{"partial"} 3 11 14
Condition100%3/3
$entry and $entry->{"partial"}
!ll&&!rl&&r
923
MC/DC100%2/2
$entry and $entry->{"partial"}
$entry $entry->{"partial"}
Truth table100%3/3
A and B
A= $entryB= $entry->{"partial"}
ABresult
0X0
100
111
867 14 $d;
868 } @rows;
869 10 my ( %via, @orphans ); # distinct item targets per covering entry
870 10 for my $key ( keys %$lock ) {
871 8 ▶ next if $declared_keys{$key};
Branch: 1 branch
BranchTrueFalseTotal
if $declared_keys{$key} 5 3 8
872 3 my $entry = $lock->{$key};
873 3 my $k = parse_lock_key($key);
874 3 ▶ my @covering = ( defined $k->{harness} && grep { $_ eq $k->{harness} } @$active ) ? _cover_of( $scope_cfg, $k, $entry ) : ();
Branch: 1 branch
BranchTrueFalseTotal
defined $k->{'harness'} && grep({$_ eq $k->{'harness'};} @$active) ? : 0 3 3
Condition33%1/3
defined $k->{"harness"} and grep {$_ eq $k->{"harness"};} @$active
!ll&&!rl&&r
030
MC/DC0%0/2
defined $k->{"harness"} and grep {$_ eq $k->{"harness"};} @$active
defined $k->{"harness"} grep {$_ eq $k->{"harness"};} @$active
Truth table33%1/3
A and B
A= defined $k->{"harness"}B= grep {$_ eq $k->{"harness"};} @$active
ABresult
0X0
100
111
875 3 my $first = $covering[0];
876 3 ▶ unless ($first) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($first) 3 0 3
877 3 push @orphans, $key;
878 3 next;
879 }
880 0 ▶ my $label = exists $first->{pattern} ? $first->{raw} : Skilletor::Resolver->bundle_label($first);
Branch: 1 branch
BranchTrueFalseTotal
exists $first->{'pattern'} ? : 0 0 0
881 0 ▶ if ( $entry->{skipped} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($entry->{"skipped"}) 0 0 0
882 0 push @declared, { key => $key, source => $entry->{source}, installed => _false, via => $label, skipped => $entry->{skipped} };
883 0 next;
884 }
885 0 my $d = { key => $key, source => $entry->{source}, installed => _true, via => $label };
886 0 ▶ $d->{partial} = _true if $entry->{partial};
Branch: 1 branch
BranchTrueFalseTotal
if $entry->{"partial"} 0 0 0
887 0 push @declared, $d;
888 0 $via{ refaddr $_ }{ $k->{target} } = 1 for @covering;
889 }
890 10 my %installed = map { ( $_->{key} => 1 ) } grep { $_->{installed} } @declared;
891 0 my %missing = map { ( $_->{key} => $_->{missing} ) } $self->_briefing_of( $scope, $lock, \%installed );
892 10 $_->{briefingMissing} = $missing{ $_->{key} } for grep { $missing{ $_->{key} } } @declared;
893 10 push @{ $out->{scopes} }, {
894 scope => $scope,
895 targets => [@$active],
896 declared => \@declared,
897 orphans => \@orphans,
898 0 ▶ wildcards => [ map { { type => $_->{type}, source => $_->{source}, entry => $_->{raw}, installed => 0 + keys %{ $via{ refaddr $_ } // {} } } }
Condition0%0/2
$via{builtin::refaddr($_)} // {}
l!l
00
MC/DC0%0/1
$via{builtin::refaddr($_)} // {}
$via{builtin::refaddr($_)}
Truth table0%0/2
A
A= $via{builtin::refaddr($_)}
Aresult
11
00
899 10 @{ $scope_cfg->{wildcards} } ],
900 0 ▶ bundles => [ map { { name => $_->{name}, source => $_->{source}, entry => $_->{raw}, installed => 0 + keys %{ $via{ refaddr $_ } // {} } } }
Condition0%0/2
$via{builtin::refaddr($_)} // {}
l!l
00
MC/DC0%0/1
$via{builtin::refaddr($_)} // {}
$via{builtin::refaddr($_)}
Truth table0%0/2
A
A= $via{builtin::refaddr($_)}
Aresult
11
00
901 10 @{ $scope_cfg->{bundles} } ],
902 trustRequests => \@trust,
903 sourceVersions => $versions,
904 };
905 }
906 10 return $out;
907 }
908  
909 31 1;
910  
911 __END__
« Skilletor/Briefing.pm ↑ Summary Skilletor/Spec.pm »