Workspace.pm

filter: Statementstmt 72.2% 120 / 166 Branchbran 48.3% 30 / 62 Conditioncond 35.5% 27 / 76 MC/DCmcdc 10.2% 4 / 39 Subroutinesub 93.7% 15 / 16 Podpod 100% 4 / 4 totaltotal 55.1% 200 / 363 CC 72 SCAR 41.9
CC
72
Cov
58%
load
141.6
new
72.1
_text
12.1
CRAP 65.9
↑ Summary Workspace/X.pm »
1 package LibTmux::Workspace;
2 2 ▶use v5.44;
Subroutine BEGIN: called CC=1 SCAR=0.0
3 2 ▶use JSON::PP ();
Subroutine BEGIN: called CC=1 SCAR=0.0
4 2 ▶use Scalar::Util qw(blessed refaddr);
Subroutine BEGIN: called CC=1 SCAR=0.0
5 2 ▶use LibTmux 0.003;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 2 ▶use LibTmux::Server;
Subroutine BEGIN: called CC=1 SCAR=0.0
7 2 ▶use LibTmux::Workspace::X;
Subroutine BEGIN: called CC=1 SCAR=0.0
8 2 our $VERSION = '0.003';
9  
10 4 ▶sub _bad ($path, $message) {
Subroutine _bad: called CC=1 SCAR=0.0
11 4 LibTmux::Workspace::X::Config->throw(path => $path, message => $message);
12 }
13  
14 29 ▶sub _object ($value, $path, @allowed) {
Subroutine _object: called CC=3 SCAR=11.1
15 29 ▶ _bad($path, 'expected an object') unless ref($value) eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
unless ref $value eq "HASH" 0 29 29
16 29 my %allowed = map { $_ => true } @allowed;
17 _bad("$path.$_", 'unknown configuration key')
18 29 for sort grep { !$allowed{$_} } keys %$value;
19 }
20  
21 9 ▶sub _text ($value, $path, $nonempty = false) {
Subroutine _text: called CC=7 SCAR=24.9
22 9 ▶ _bad($path, 'expected a NUL-free string')
Branch: 1 branch
BranchTrueFalseTotal
unless defined $value and not ref $value and not $value =~ /\0/u and !$nonempty || length $value 0 9 9
Condition41%5/12
defined $value and not ref $value and not $value =~ /\0/u and !$nonempty || length $value
!ll&&!rl&&r
009
defined $value and not ref $value and not $value =~ /\0/u
!ll&&!rl&&r
009
defined $value and not ref $value
!ll&&!rl&&r
009
not $nonempty or length $value
l!l&&r!l&&!r
270
MC/DC0%0/5
defined $value and not ref $value and not $value =~ /\0/u and !$nonempty || length $value
defined $value not ref $value not $value =~ /\0/u not $nonempty length $value
Truth table33%2/6
A and not(B) and not(C) and not(D) or E
A= defined $valueB= not ref $valueC= not $value =~ /\0/uD= not $nonemptyE= length $value
ABCDEresult
0XXXX0
10XXX0
110XX0
111000
1111X1
111011
23 unless defined($value)
24 && !ref($value)
25 && $value !~ /\0/
26 && (!$nonempty || length $value);
27 9 return "$value";
28 }
29  
30 13 ▶sub _env ($value, $path) {
Subroutine _env: called CC=5 SCAR=20.1
31 13 ▶ _object($value, $path, keys %$value) if ref($value) eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $value eq "HASH" 13 0 13
32 13 ▶ _bad($path, 'expected an environment object') unless ref($value) eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
unless ref $value eq "HASH" 0 13 13
33 13 my %out;
34 13 for my $name (sort keys %$value) {
35 0 ▶ _bad("$path.$name", 'invalid environment name')
Branch: 1 branch
BranchTrueFalseTotal
unless $name =~ /\A[A-Za-z_][A-Za-z_0-9]*\z/u 0 0 0
36 unless $name =~ /\A[A-Za-z_][A-Za-z_0-9]*\z/;
37 0 $out{$name} = _text($value->{$name}, "$path.$name");
38 }
39 13 return \%out;
40 }
41  
42 9 ▶sub _list ($value, $path) {
Subroutine _list: called CC=3 SCAR=11.1
43 9 ▶ _bad($path, 'expected a nonempty array')
Branch: 1 branch
BranchTrueFalseTotal
unless ref $value eq "ARRAY" and @$value 1 8 9
Condition66%2/3
ref $value eq "ARRAY" and @$value
!ll&&!rl&&r
018
MC/DC50%1/2
ref $value eq "ARRAY" and @$value
ref $value eq "ARRAY" @$value
Truth table66%2/3
A and B
A= ref $value eq "ARRAY"B= @$value
ABresult
0X0
100
111
44 unless ref($value) eq 'ARRAY' && @$value;
45 }
46  
47 6 ▶sub new ($class, %args) {
Subroutine new: called CC=30 SCAR=42.8
Pod documented
48 _bad('options', 'only config is accepted')
49 6 ▶ if grep { $_ ne 'config' } keys %args;
Branch: 1 branch
BranchTrueFalseTotal
if grep {$_ ne "config";} keys %args 0 6 6
50 6 my $raw = $args{config};
51 6 _object($raw, 'workspace', qw(schema sessions environment));
52 _bad('workspace.schema', 'expected libtmux.workspace/v1')
53 unless defined($raw->{schema})
54 && !ref($raw->{schema})
55 5 ▶ && $raw->{schema} eq 'libtmux.workspace/v1';
Branch: 1 branch
BranchTrueFalseTotal
unless defined $raw->{"schema"} and not ref $raw->{"schema"} and $raw->{"schema"} eq "libtmux.workspace/v1" 1 4 5
Condition50%3/6
defined $raw->{"schema"} and not ref $raw->{"schema"} and $raw->{"schema"} eq "libtmux.workspace/v1"
!ll&&!rl&&r
014
defined $raw->{"schema"} and not ref $raw->{"schema"}
!ll&&!rl&&r
005
MC/DC33%1/3
defined $raw->{"schema"} and not ref $raw->{"schema"} and $raw->{"schema"} eq "libtmux.workspace/v1"
defined $raw->{"schema"} not ref $raw->{"schema"} $raw->{"schema"} eq "libtmux.workspace/v1"
Truth table50%2/4
A and not(B) and C
A= defined $raw->{"schema"}B= not ref $raw->{"schema"}C= $raw->{"schema"} eq "libtmux.workspace/v1"
ABCresult
0XX0
10X0
1100
1111
56 _bad('workspace.sessions', 'expected an array')
57 4 ▶ unless ref($raw->{sessions}) eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
unless ref $raw->{"sessions"} eq "ARRAY" 0 4 4
58 4 ▶ my $global = _env($raw->{environment} // {}, 'workspace.environment');
Condition50%1/2
$raw->{"environment"} // {}
l!l
04
MC/DC0%0/1
$raw->{"environment"} // {}
$raw->{"environment"}
Truth table50%1/2
A
A= $raw->{"environment"}
Aresult
11
00
59 4 my (@sessions, %names);
60 4 my $i = 0;
61  
62 4 for my $session ($raw->{sessions}->@*) {
63 4 my $path = 'workspace.sessions[' . $i++ . ']';
64 4 _object($session, $path, qw(name environment windows));
65 4 my $name = _text($session->{name}, "$path.name", true);
66 4 ▶ _bad("$path.name",
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /[:.\n\r]/u 0 4 4
67 'tmux session names cannot contain colon, period, or newline')
68 if $name =~ /[:.\n\r]/;
69 4 ▶ _bad("$path.name", 'duplicate session name') if $names{$name}++;
Branch: 1 branch
BranchTrueFalseTotal
if $names{$name}++ 0 4 4
70 my %environment = (
71 %$global,
72 4 ▶ %{_env($session->{environment} // {}, "$path.environment")}
Condition50%1/2
$session->{"environment"} // {}
l!l
04
MC/DC0%0/1
$session->{"environment"} // {}
$session->{"environment"}
Truth table50%1/2
A
A= $session->{"environment"}
Aresult
11
00
73 );
74 4 _list($session->{windows}, "$path.windows");
75 3 my (@windows, %window_names);
76 3 my $j = 0;
77  
78 3 for my $window ($session->{windows}->@*) {
79 3 my $wp = "$path.windows[" . $j++ . ']';
80 3 _object($window, $wp, qw(name cwd layout panes environment));
81 my $window_name =
82 3 ▶ _text($window->{name} // 'window', "$wp.name", true);
Condition100%2/2
$window->{"name"} // "window"
l!l
12
MC/DC100%1/1
$window->{"name"} // "window"
$window->{"name"}
Truth table100%2/2
A
A= $window->{"name"}
Aresult
11
00
83 _bad("$wp.name", 'duplicate window name')
84 3 ▶ if $window_names{$window_name}++;
Branch: 1 branch
BranchTrueFalseTotal
if $window_names{$window_name}++ 0 3 3
85 my %window_env = (
86 %environment,
87 3 ▶ %{_env($window->{environment} // {}, "$wp.environment")}
Condition50%1/2
$window->{"environment"} // {}
l!l
03
MC/DC0%0/1
$window->{"environment"} // {}
$window->{"environment"}
Truth table50%1/2
A
A= $window->{"environment"}
Aresult
11
00
88 );
89 3 _list($window->{panes}, "$wp.panes");
90 3 my @panes;
91 3 my $k = 0;
92  
93 3 for my $pane ($window->{panes}->@*) {
94 3 my $pp = "$wp.panes[" . $k++ . ']';
95 3 _object($pane, $pp,
96 qw(command shell_command cwd environment horizontal));
97 _bad($pp,
98 'exactly one of command and shell_command is required')
99 if exists($pane->{command}) ==
100 3 ▶ exists($pane->{shell_command});
Branch: 1 branch
BranchTrueFalseTotal
if exists $pane->{"command"} == exists $pane->{"shell_command"} 1 2 3
101 my %out = (
102 environment => {
103 %window_env,
104 %{
105 2 ▶ _env($pane->{environment} // {}, "$pp.environment")
Condition50%1/2
$pane->{"environment"} // {}
l!l
02
MC/DC0%0/1
$pane->{"environment"} // {}
$pane->{"environment"}
Truth table50%1/2
A
A= $pane->{"environment"}
Aresult
11
00
106 }
107 }
108 );
109 2 ▶ if (exists $pane->{command}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $pane->{'command'}) { } 2 0 2
110 2 _list($pane->{command}, "$pp.command");
111 $out{command} =
112 2 [map { _text($_, "$pp.command") } $pane->{command}->@*];
113 }
114 else {
115 $out{shell_command} =
116 0 _text($pane->{shell_command}, "$pp.shell_command");
117 }
118 $out{cwd} =
119 _text($pane->{cwd} // $window->{cwd}, "$pp.cwd", true)
120 2 ▶ if exists($pane->{cwd}) || exists($window->{cwd});
Branch: 1 branch
BranchTrueFalseTotal
if exists $pane->{"cwd"} or exists $window->{"cwd"} 0 2 2
Condition16%1/6
exists $pane->{"cwd"} or exists $window->{"cwd"}
l!l&&r!l&&!r
002
$pane->{"cwd"} // $window->{"cwd"}
l!l&&r!l&&!r
000
MC/DC0%0/2
exists $pane->{"cwd"} or exists $window->{"cwd"}
exists $pane->{"cwd"} exists $window->{"cwd"}
MC/DC0%0/2
$pane->{"cwd"} // $window->{"cwd"}
$pane->{"cwd"} $window->{"cwd"}
Truth table33%1/3
A or B
A= exists $pane->{"cwd"}B= exists $window->{"cwd"}
ABresult
1X1
011
000
Truth table0%0/3
A // B
A= $pane->{"cwd"}B= $window->{"cwd"}
ABresult
1X1
011
000
121 2 ▶ if (exists $pane->{horizontal}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $pane->{"horizontal"}) 0 2 2
122 _bad("$pp.horizontal", 'expected Boolean or 0/1')
123 unless !ref($pane->{horizontal})
124 && defined($pane->{horizontal})
125 && (JSON::PP::is_bool($pane->{horizontal})
126 0 ▶ || "$pane->{horizontal}" eq '0'
Branch: 1 branch
BranchTrueFalseTotal
unless not ref $pane->{"horizontal"} and defined $pane->{"horizontal"} and JSON::PP::is_bool($pane->{"horizontal"}) || qq[$pane->{"horizontal"}] eq 0 || qq[$pane->{"horizontal"}] eq 1 0 0 0
Condition0%0/12
not ref $pane->{"horizontal"} and defined $pane->{"horizontal"} and JSON::PP::is_bool($pane->{"horizontal"}) || qq[$pane->{"horizontal"}] eq 0 || qq[$pane->{"horizontal"}] eq 1
!ll&&!rl&&r
000
not ref $pane->{"horizontal"} and defined $pane->{"horizontal"}
!ll&&!rl&&r
000
JSON::PP::is_bool($pane->{"horizontal"}) or qq[$pane->{"horizontal"}] eq 0 or qq[$pane->{"horizontal"}] eq 1
l!l&&r!l&&!r
000
JSON::PP::is_bool($pane->{"horizontal"}) or qq[$pane->{"horizontal"}] eq 0
l!l&&r!l&&!r
000
MC/DC0%0/5
not ref $pane->{"horizontal"} and defined $pane->{"horizontal"} and JSON::PP::is_bool($pane->{"horizontal"}) || qq[$pane->{"horizontal"}] eq 0 || qq[$pane->{"horizontal"}] eq 1
not ref $pane->{"horizontal"} defined $pane->{"horizontal"} JSON::PP::is_bool($pane->{"horizontal"}) qq[$pane->{"horizontal"}] eq 0 qq[$pane->{"horizontal"}] eq 1
Truth table0%0/6
not(A) and B and C or D or E
A= not ref $pane->{"horizontal"}B= defined $pane->{"horizontal"}C= JSON::PP::is_bool($pane->{"horizontal"})D= qq[$pane->{"horizontal"}] eq 0E= qq[$pane->{"horizontal"}] eq 1
ABCDEresult
0XXXX0
10XXX0
110000
111XX1
1101X1
110011
127 || "$pane->{horizontal}" eq '1');
128 0 ▶ $out{horizontal} = $pane->{horizontal} ? true : false;
Branch: 1 branch
BranchTrueFalseTotal
$pane->{'horizontal'} ? : 0 0 0
129 }
130 2 push @panes, \%out;
131 }
132 2 my %out = (name => $window_name, panes => \@panes);
133 $out{layout} = _text($window->{layout}, "$wp.layout", true)
134 2 ▶ if exists $window->{layout};
Branch: 1 branch
BranchTrueFalseTotal
if exists $window->{"layout"} 0 2 2
135 2 push @windows, \%out;
136 }
137 2 push @sessions,
138 {name => $name, environment => \%environment, windows => \@windows};
139 }
140 return
141 2 bless {
142 config => {schema => 'libtmux.workspace/v1', sessions => \@sessions}
143 }, $class;
144 }
145  
146 0 ▶sub from_json ($class, $json) {
Subroutine from_json: not called CC=1 SCAR=6.9
Pod documented
147 0 my $data;
148 0 try {
149 0 $data =
150 JSON::PP->new->utf8->core_bools->max_size(1024 * 1024)
151 ->max_depth(32)
152 ->decode($json)
153 }
154 0 catch ($error) { _bad('workspace', 'invalid or oversized JSON: ' . $error) }
155 0 return $class->new(config => $data);
156 }
157  
158 84 ▶sub _copy ($value) {
Subroutine _copy: called CC=3 SCAR=11.0
159 84 ▶ return {map { $_ => _copy($value->{$_}) } keys %$value}
Branch: 1 branch
BranchTrueFalseTotal
if ref $value eq "HASH" 35 49 84
160 if ref($value) eq 'HASH';
161 49 ▶ return [map { _copy($_) } @$value] if ref($value) eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
if ref $value eq "ARRAY" 28 21 49
162 21 return $value;
163 }
164  
165 7 ▶sub plan ($self, %args) {
Subroutine plan: called CC=4 SCAR=14.9
Pod documented
166 7 ▶ my $existing = $args{existing} // 'error';
Condition100%2/2
$args{"existing"} // "error"
l!l
43
MC/DC100%1/1
$args{"existing"} // "error"
$args{"existing"}
Truth table100%2/2
A
A= $args{"existing"}
Aresult
11
00
167 7 ▶ _bad('existing', 'expected error or skip')
Branch: 1 branch
BranchTrueFalseTotal
unless not ref $existing and $existing =~ /\A(?:error|skip)\z/u 0 7 7
Condition33%1/3
not ref $existing and $existing =~ /\A(?:error|skip)\z/u
!ll&&!rl&&r
007
MC/DC0%0/2
not ref $existing and $existing =~ /\A(?:error|skip)\z/u
not ref $existing $existing =~ /\A(?:error|skip)\z/u
Truth table33%1/3
not(A) and B
A= not ref $existingB= $existing =~ /\A(?:error|skip)\z/u
ABresult
0X0
100
111
168 unless !ref($existing) && $existing =~ /\A(?:error|skip)\z/;
169 return {
170 schema => 'libtmux.workspace.plan/v1',
171 existing => $existing,
172 mutates => false,
173 7 sessions => _copy($self->{config}{sessions}),
174 completion =>
175 'command acceptance and captured handles; application readiness requires caller assertions'
176 };
177 }
178  
179 4 ▶sub load ($self, %args) {
Subroutine load: called CC=24 SCAR=49.5
Pod documented
180 4 my $server = $args{server};
181 4 ▶ _bad('server', 'expected a synchronous public LibTmux::Server')
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($server) and $server->isa("LibTmux::Server") 0 4 4
Condition33%1/3
builtin::blessed($server) and $server->isa("LibTmux::Server")
!ll&&!rl&&r
004
MC/DC0%0/2
builtin::blessed($server) and $server->isa("LibTmux::Server")
builtin::blessed($server) $server->isa("LibTmux::Server")
Truth table33%1/3
A and B
A= builtin::blessed($server)B= $server->isa("LibTmux::Server")
ABresult
0X0
100
111
182 unless blessed($server) && $server->isa('LibTmux::Server');
183 4 ▶ my $plan = $self->plan(existing => $args{existing} // 'error');
Condition50%1/2
$args{"existing"} // "error"
l!l
04
MC/DC0%0/1
$args{"existing"} // "error"
$args{"existing"}
Truth table50%1/2
A
A= $args{"existing"}
Aresult
11
00
184 4 my %existing;
185 4 try {
186 0 %existing = map { $_->name => $_ } $server->snapshot->sessions->@*
187 }
188 catch ($error) {
189 0 ▶ die $error unless blessed($error) && $error->isa('LibTmux::X::NoServer')
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($error) and $error->isa("LibTmux::X::NoServer") 0 0 0
Condition0%0/3
builtin::blessed($error) and $error->isa("LibTmux::X::NoServer")
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($error) and $error->isa("LibTmux::X::NoServer")
builtin::blessed($error) $error->isa("LibTmux::X::NoServer")
Truth table0%0/3
A and B
A= builtin::blessed($error)B= $error->isa("LibTmux::X::NoServer")
ABresult
0X0
100
111
190 }
191 4 ▶ if ($plan->{existing} eq 'error') {
Branch: 1 branch
BranchTrueFalseTotal
if ($plan->{"existing"} eq "error") 4 0 4
192 4 for my $session ($plan->{sessions}->@*) {
193 LibTmux::Workspace::X::Conflict->throw(
194 message => 'session already exists: ' . $session->{name})
195 4 ▶ if $existing{$session->{name}};
Branch: 1 branch
BranchTrueFalseTotal
if $existing{$session->{"name"}} 0 4 4
196 }
197 }
198 4 my $report = {
199 status => 'loading',
200 created => [],
201 skipped => [],
202 steps => [],
203 cleanup_errors => []
204 };
205 4 my @owned;
206 my $step;
207 4 try {
208 4 for my $session ($plan->{sessions}->@*) {
209 4 ▶ if ($existing{$session->{name}}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($existing{$session->{"name"}}) 0 4 4
210 0 push $report->{skipped}->@*, $session->{name};
211 0 next;
212 }
213 4 $step = 'create session ' . $session->{name};
214 4 my $first_window = $session->{windows}[0];
215 4 my %first = %{$first_window->{panes}[0]};
216 4 delete $first{horizontal};
217 my $created =
218 4 $server->new_session(name => $session->{name}, %first);
219 0 push @owned, $created;
220 0 push $report->{created}->@*, $created->id;
221 0 push $report->{steps}->@*, $step;
222  
223 0 for my $name (sort keys $session->{environment}->%*) {
224 0 $step = 'set environment ' . $session->{name} . '.' . $name;
225 $server->set_environment(
226 session => $created,
227 name => $name,
228 0 value => $session->{environment}{$name}
229 );
230 0 push $report->{steps}->@*, $step;
231 }
232 0 my $index = 0;
233 0 for my $window ($session->{windows}->@*) {
234 $step =
235 0 'create window ' . $session->{name} . ':' . $window->{name};
236 0 my $physical;
237 0 ▶ if (!$index++) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $index++) { } 0 0 0
238 0 $physical = $created->window_links->first->window;
239 $server->rename_window(
240 window => $physical,
241 name => $window->{name}
242 0 );
243 }
244 else {
245 0 my %pane = %{$window->{panes}[0]};
246 0 delete $pane{horizontal};
247 $physical = $server->new_window(
248 session => $created,
249 name => $window->{name},
250 0 %pane
251 );
252 }
253 0 push $report->{steps}->@*, $step;
254 0 my $target = $physical->panes->first;
255 0 for my $i (1 .. $#{$window->{panes}}) {
256 $step =
257 'split pane '
258 . $session->{name} . ':'
259 0 . $window->{name} . ':'
260 . $i;
261 $target = $server->split_pane(
262 pane => $target,
263 0 %{$window->{panes}[$i]}
264 );
265 0 push $report->{steps}->@*, $step;
266 }
267 0 ▶ if (exists $window->{layout}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $window->{"layout"}) 0 0 0
268 $step =
269 0 'layout ' . $session->{name} . ':' . $window->{name};
270 $server->select_layout(
271 window => $physical,
272 layout => $window->{layout}
273 0 );
274 0 push $report->{steps}->@*, $step;
275 }
276 }
277 }
278 0 $report->{status} = 'loaded';
279 }
280 catch ($error) {
281 4 ▶ if ( blessed($error)
Branch: 1 branch
BranchTrueFalseTotal
if (builtin::blessed($error) and $error->isa("LibTmux::X::Creation") and $error->created and $error->created->kind eq "session") 4 0 4
Condition33%3/9
builtin::blessed($error) and $error->isa("LibTmux::X::Creation") and $error->created and $error->created->kind eq "session"
!ll&&!rl&&r
004
builtin::blessed($error) and $error->isa("LibTmux::X::Creation") and $error->created
!ll&&!rl&&r
004
builtin::blessed($error) and $error->isa("LibTmux::X::Creation")
!ll&&!rl&&r
004
MC/DC0%0/4
builtin::blessed($error) and $error->isa("LibTmux::X::Creation") and $error->created and $error->created->kind eq "session"
builtin::blessed($error) $error->isa("LibTmux::X::Creation") $error->created $error->created->kind eq "session"
Truth table20%1/5
A and B and C and D
A= builtin::blessed($error)B= $error->isa("LibTmux::X::Creation")C= $error->createdD= $error->created->kind eq "session"
ABCDresult
0XXX0
10XX0
110X0
11100
11111
282 && $error->isa('LibTmux::X::Creation')
283 && $error->created
284 && $error->created->kind eq 'session')
285 {
286 4 push @owned, $error->created;
287 4 push $report->{created}->@*, $error->created->id;
288 }
289 4 $report->{status} = 'failed';
290 4 $report->{failed_step} = $step;
291 $report->{dispatch_uncertain} =
292 4 ▶ blessed($error) && $error->isa('LibTmux::X')
Branch: 1 branch
BranchTrueFalseTotal
builtin::blessed($error) && $error->isa('LibTmux::X') ? : 4 0 4
Condition40%2/5
builtin::blessed($error) and $error->isa("LibTmux::X")
!ll&&!rl&&r
004
$error->dispatched //
l!l
40
MC/DC0%0/2
builtin::blessed($error) and $error->isa("LibTmux::X")
builtin::blessed($error) $error->isa("LibTmux::X")
MC/DC0%0/1
$error->dispatched //
$error->dispatched
Truth table33%1/3
A and B
A= builtin::blessed($error)B= $error->isa("LibTmux::X")
ABresult
0X0
100
111
Truth table50%1/2
A
A= $error->dispatched
Aresult
11
00
293 ? $error->dispatched // true
294 : true;
295 4 for my $owned (reverse @owned) {
296 4 try { $server->kill_session(session => $owned) }
297 catch ($cleanup) {
298 push $report->{cleanup_errors}->@*,
299 {
300 4 target => $owned->identity,
301 action => 'kill_session',
302 error => $cleanup,
303 };
304 }
305 }
306 LibTmux::Workspace::X::Load->throw(
307 4 message => 'workspace load failed at ' . $step,
308 cause => $error,
309 report => $report
310 );
311 }
312 0 return $report;
313 }
314  
315 =head1 NAME
316  
317 LibTmux::Workspace - Versioned JSON configuration and owned orchestration
318  
319 =head1 SYNOPSIS
320  
321 use LibTmux::Workspace;
322 my $workspace = LibTmux::Workspace->from_json($json_octets);
323 my $plan = $workspace->plan(existing => 'error');
324 my $report = $workspace->load(server => $server);
325  
326 =head1 METHODS
327  
328 =head2 new
329  
330 C<new(config =E<gt> $hashref)> validates and copies a
331 C<libtmux.workspace/v1> configuration. No I/O occurs. Sessions contain named
332 windows with nonempty pane arrays. Each pane requires literal C<command>
333 arguments or an explicit C<shell_command>. Environment values inherit from
334 workspace, session, and window, with pane values taking precedence. All
335 configuration errors throw L<Config|LibTmux::Workspace::X/Config>.
336  
337 =head2 from_json
338  
339 Decode bounded UTF-8 JSON octets with core L<JSON::PP> and call L</new>.
340 Reject unsupported versions, unknown keys, invalid commands, and duplicate
341 names. YAML is not part of this distribution.
342  
343 =head2 plan
344  
345 C<plan(existing =E<gt> 'error'|'skip')> returns a fresh data plan in input
346 order. It performs no tmux I/O or mutations. A dry-run does not prove live
347 availability or command success. Exports share no mutable arrays with the
348 loader. No context-dependent return values are used.
349  
350 =head2 load
351  
352 C<load(server =E<gt> $server, existing =E<gt> 'error'|'skip')> uses public
353 L<LibTmux::Server> operations. It checks all session-name conflicts before
354 creation. C<error> rejects any existing target with
355 L<Conflict|LibTmux::Workspace::X/Conflict>; C<skip> leaves that entire session
356 alone, so repeated application creates only absent sessions. A missing server
357 permits explicit creation; other acquisition failures propagate.
358  
359 Return one report containing created IDs, skipped names, and completed steps.
360 On failure, rollback only sessions returned by successful creation, then throw
361 L<Load|LibTmux::Workspace::X/Load> with original cause and partial-effect report.
362 An uncertain creation without a returned ID cannot be rolled back safely.
363 Existing resources are never rollback targets. Layouts apply after splitting;
364 working directories and environments reach every initial process. Completion
365 means command acceptance and captured state, not application readiness.
366  
367 =head1 COMMAND LINE
368  
369 The packaged C<libtmux-workspace> executable exposes C<validate>, C<plan>, and
370 C<load>. C<--dry-run> selects planning without tmux I/O. See the installed
371 executable's help for socket and repeat-application options.
372  
373 =head1 DOCUMENTATION
374  
375 Read the L<Perl documentation|https://libtmux.org/en/perl/> and
376 L<workspace guide|https://libtmux.org/en/perl/latest/workspace/source-guide/>
377 for complete configuration and CLI examples. The
378 L<API reference|https://libtmux.org/en/perl/latest/workspace/reference/libtmux-workspace/>
379 documents validation, planning, loading, and failure reports. The
380 L<CPAN distribution|https://metacpan.org/dist/LibTmux-Workspace> includes
381 runnable consumer examples. The C<0.x> API can change between releases.
382  
383 =cut
↑ Summary Workspace/X.pm »