blib/lib/Ei.pm untested

filter: Statementstmt 0.0% 0 / 294 Branchbran 0.0% 0 / 118 Conditioncond 0.0% 0 / 76 MC/DCmcdc 0.0% 0 / 43 Subroutinesub 0.0% 0 / 37 Podpod 0.0% 0 / 32 totaltotal 0.0% 0 / 600 CC 60 SCAR 34.8
CC
60
Cov
0%
merge
72.0
_read_items
72.0
ask
72.0
CRAP 32.4
1 package Ei;
2  
3 use strict;
4 use warnings;
5  
6 use File::Basename qw(dirname);
7 use File::Spec;
8  
9 use vars qw($VERSION);
10  
11 $VERSION = '0.07';
12  
13 sub new {
14 my $cls = shift;
15 unshift @_, 'file' if @_ % 2;
16 my $self = bless {
17 @_,
18 }, $cls;
19 my $conf = $self->{config} = $self->_read_config($self->{config_file});
20 my $root = $self->{root} ||= glob($conf->{files}{root});
21 my $file = $self->{file};
22 if (!defined $file) {
23 ($file) = glob($conf->{files}{main});
24 die "no file from which to read inventory" if !defined $file;
25 }
26 $self->{defaults} = $conf->{items}{defaults} || {};
27 $self->{file} = File::Spec->rel2abs($file, $root) if $file !~ m{^/};
28 $self->{interactive} ||= -t STDIN;
29 return $self;
30 }
31  
32 sub file { $_[0]->{file} }
33  
34 sub find {
35 my $self = shift;
36 my @items = $self->items;
37 }
38  
39 sub items {
40 my ($self) = @_;
41 return @{ $self->{'items'} ||= [ $self->_read_items($self->file) ] };
42 }
43  
44 sub item {
45 my ($self, $id) = @_;
46 my $items = $self->{'items_by_id'} ||= { map { $_->{'#'} => $_ } $self->items };
47 return $items->{$id};
48 }
49  
50 sub locations {
51 my ($self) = @_;
52 return $self->{config}{locations} ||= {};
53 }
54  
55 sub reload {
56 my $self = shift;
57 if (@_) {
58 die "not yet implemented";
59 }
60 else {
61 my $file = $self->file;
62 $self->{'items'} = [ $self->_read_items($file) ];
63 delete $self->{'items_by_id'};
64 }
65 return $self;
66 }
67  
68 sub merge {
69 my ($self, $obj, $k, $op, $v) = @_;
70 my $d = $obj;
71 my $r = ref $obj;
72 while ($k =~ /[\[\].]/) {
73 if ($k =~ s/^([^\[.]+)\.//) {
74 $d = $d->{$1} ||= {};
75 }
76 else {
77 die "Huh?";
78 }
79 $r = ref $d;
80 }
81 if ($op eq '+') {
82 my $vprev = $d->{$k};
83 my $r = defined $vprev ? ref $vprev : '';
84 if ($r eq '') {
85 $d->{$k} = [ defined $vprev ? ($vprev) : (), $v ];
86 }
87 elsif ($r eq 'ARRAY') {
88 push @$vprev, $v;
89 }
90 else {
91 die "attempt to add to non-list: $vprev <= $k $op $v";
92 }
93 }
94 elsif ($op eq '=') {
95 $d->{$k} = $v;
96 }
97 }
98  
99 sub _read_file {
100 my ($self, $f, %defaults) = @_;
101 open my $fh, '<', $f or die "Can't open $f $!";
102 my %hash;
103 while (<$fh>) {
104 next if /^\s*(?:#.*)?$/;
105 if (/^!include\s+(\S+)$/) {
106 my $source = File::Spec->rel2abs($1, dirname($f));
107 my @files = -d $source ? grep { -f } glob("$source/*.ei") : (glob($source));
108 foreach my $f (@files) {
109 %hash = ( %hash, %{ $self->_read_file($f, %defaults) } );
110 }
111 }
112 elsif (s/^\s*(\S+)\s+//) {
113 my $key = $1;
114 my $val = $self->_read_value($_, $fh, $f, $.);
115 $hash{$key} = $val;
116 }
117 else {
118 die qq{Expected a value at file $f line $.};
119 }
120 }
121 return \%hash;
122 }
123  
124 sub _read_items {
125 my ($self, $f, %defaults) = @_;
126 open my $fh, '<', $f or die "Can't open $f $!";
127 my @items;
128 while (<$fh>) {
129 next if /^\s*(?:#.*)?$/;
130 chomp;
131 if (/^!include\s+(\S+)$/) {
132 my $source = File::Spec->rel2abs($1, dirname($f));
133 my @files = -d $source ? grep { -f } glob("$source/*.ei") : (glob($source));
134 foreach my $f (@files) {
135 push @items, $self->_read_items($f, %defaults);
136 }
137 }
138 elsif (/^!default\s+(\S+)\s+(.*)$/) {
139 $defaults{$1} = $2;
140 }
141 elsif (s/^\s*(?:"(\\.|[^\\"])+"|(\S+))\s+(?=\{)//) {
142 my $key = defined $1 ? unquote($1) : $2;
143 my $isdef = $key eq '*';
144 my $line = $.;
145 my %item = (
146 %{ $self->{'defaults'} },
147 %defaults,
148 %{ $self->_read_value($_, $fh, $f, $.) },
149 );
150 if ($isdef) {
151 %defaults = ( %defaults, %item );
152 }
153 else {
154 $item{'#'} = $key;
155 $item{'/'} = $f;
156 $item{'.'} = $line;
157 push @items, \%item;
158 }
159 }
160 # elsif (s/^\s*(\S+)\s+//) {
161 # my $key = $1;
162 # my $val = $self->_read_value($_, $fh, $f, $.);
163 # die "Value $val is not a hash" if ref($val) ne 'HASH';
164 # $val->{'#'} = $key;
165 # push @items, $val;
166 # }
167 else {
168 die qq{Expected hash element at line $. of $f};
169 }
170 }
171 return @items;
172 }
173  
174 sub _read_value {
175 my $self = shift;
176 local $_ = shift;
177 my ($fh, $f, $l) = @_;
178 return [ map { trim($_) } split /,/, $1 ] if /^\s*\[(.+)\]\s*$/;
179 return { map { my ($k, $v) = split /\s+/; (trim($k), trim($v)) } split /,/, $1 } if /^\s*\{(.+)\}\s*$/;
180 return unquote($1) if /^\s*"(.+)"\s*$/;
181 return $self->_read_array($fh, $f, $l) if /^\s*\[\s*$/;
182 return $self->_read_hash($fh, $f, $l) if /^\s*\{\s*$/;
183 return $self->_read_string($fh, $f, $l) if /^\s*\"\s*$/;
184 #die if !/^(.*)$/;
185 return trim($_);
186 }
187  
188 sub _read_array {
189 my ($self, $fh, $f, $l) = @_;
190 my (@array, $ok);
191 my $i = 0;
192 while (<$fh>) {
193 next if /^\s*(?:#.*)?$/;
194 $ok = 1, last if /^\s*\]\s*$/;
195 $array[$i++] = $self->_read_value($_, $fh, $f, $.);
196 }
197 die "Unterminated array at line $l of $f" if !$ok;
198 return \@array;
199 }
200  
201 sub _read_hash {
202 my ($self, $fh, $f, $l) = @_;
203 my (%hash, $ok);
204 while (<$fh>) {
205 next if /^\s*(?:#.*)?$/;
206 $ok = 1, last if /^\s*\}\s*$/;
207 s/^\s*(?:"(\\.|[^\\"])+"|(\S+))(?=\s)//
208 or die "Not a hash element: $_";
209 my $key = defined $1 ? unquote($1) : $2;
210 my $val = $self->_read_value($_, $fh, $f, $.);
211 $hash{$key} = $val;
212 }
213 die "Unterminated hash at line $l of $f" if !$ok;
214 return \%hash;
215 }
216  
217 sub _read_string {
218 my ($self, $fh, $f, $l) = @_;
219 my (@array, $ok);
220 my $str = '';
221 while (<$fh>) {
222 $ok = 1, last if /^\s*\"\s*$/;
223 $str .= $_;
224 }
225 die "Unterminated string at line $l of $f" if !$ok;
226 chomp $str;
227 return $str;
228 }
229  
230 sub _read_config {
231 my ($self, $f) = @_;
232 my $hash = $self->_read_file($f);
233 return $hash;
234 open my $fh, '<', $f or die "Can't open $f $!";
235 while (<$fh>) {
236 next if /^\s*(?:#.*)?$/;
237 s/^config\s+// or die "Bad config file $f: $_";
238 return $self->_read_hash($fh, $f, $.);
239 }
240 }
241  
242 sub write {
243 my ($self, $fh, @items) = @_;
244 foreach my $item (@items) {
245 my $id = delete $item->{'#'} // delete $item->{id};
246 my $str = $self->serialize($item);
247 print $fh $id, ' ', $str, "\n\n";
248 }
249 }
250  
251 sub prototypes {
252 my ($self) = @_;
253 return keys %{ $self->{config}{prototypes} };
254 }
255  
256 sub prototype {
257 my ($self, $p) = @_;
258 my $proto = $self->{config}{prototypes}{$p} or return;
259 if (my $inherit = $proto->{inherit}) {
260 %{ $proto->{properties} } = (
261 %{ $self->prototype($inherit)->{properties} },
262 %{ $proto->{properties} },
263 );
264 }
265 return $proto;
266 }
267  
268 sub serialize {
269 my ($self, $item) = @_;
270 return join "\n", _serialize(0, $item);
271 }
272  
273 sub _serialize {
274 my ($level, $val) = @_;
275 my $r = ref $val;
276 if ($r eq 'HASH') {
277 return _serialize_hash($level+1, $val);
278 }
279 elsif ($r eq 'ARRAY') {
280 return _serialize_array($level+1, $val);
281 }
282 else {
283 die if $r ne '';
284 return $val if $val !~ /^\s/ && $val !~ /^[\\\[\]\{\}]/;
285 $val =~ s/([\\\[\]\{\}])/\\$1/g;
286 return $val;
287 }
288 }
289  
290 sub _serialize_hash {
291 my ($level, $hash) = @_;
292 my @out = '{';
293 my $indstr = ' ' x ($level-0);
294 foreach my $k (sort keys %$hash) {
295 my $v = $hash->{$k};
296 my @val = _serialize($level, $v);
297 push @out, sprintf('%s%s %s', $indstr, $k, shift @val);
298 push @out, @val;
299 }
300 $indstr =~ s/ $//;
301 return @out, $indstr.'}';
302 }
303  
304 sub unquote {
305 local $_ = shift;
306 s/\\(.)/$1/g;
307 return $_;
308 }
309  
310 sub trim {
311 local $_ = shift;
312 return '' if !defined;
313 s/^\s+|\s+$//g;
314 return $_;
315 }
316  
317 sub fill_placeholders {
318 my ($self, $obj, %actions) = @_;
319 my %placeholders = placeholders($obj);
320 my %order = qw(
321 id 00000
322 uuid 00001
323 title 00002
324 location 00003
325 );
326 my @ordered_placeholders = sort {
327 my ($ak, $bk) = map { $_->[0] } $a, $b;
328 ($order{$ak} // $ak)
329 cmp
330 ($order{$bk} // $bk)
331 } values %placeholders;
332 foreach (@ordered_placeholders) {
333 my ($key, $setter, $action, @args) = @$_;
334 $key =~ s/^\.// or die "Huh?";
335 my $sub = $self->can('ph_'.$action) || $actions{$action} || $actions{'*'}
336 || die "Unknown placeholder action: $action";
337 $sub->($self, $key, $setter, @args);
338 last if !$self->{running};
339 }
340 }
341  
342  
343 # --- Placeholder handlers
344  
345 sub ph_mint {
346 my ($self, $key, $setter, $m, @etc) = @_;
347 my $minter = $self->{config}{minters}{$m} or die "No such minter: $m";
348 my ($cmd, $args) = @$minter{qw(command arguments)};
349 open my $fh, '-|', $cmd, @{ $args || [] } or die;
350 my $val = <$fh>;
351 die "$cmd: no value returned" if !defined $val;
352 chomp $val;
353 $setter->($val);
354 my $label = $self->{config}{labels}{$key} // ucfirst $key;
355 print STDERR " $label: $val\n";
356 }
357  
358 sub ph_string {
359 my ($self, $key, $setter, @args) = @_;
360 my $label = $self->{config}{labels}{$key} // ucfirst $key;
361 $setter->($self->ask($label));
362 }
363  
364 sub ph_list {
365 my ($self, $key, $setter, @args) = @_;
366 my $label = $self->{config}{labels}{$key} // ucfirst $key;
367 $setter->([ split /,\s*/, $self->ask($label) ]);
368 }
369  
370 sub ph_location {
371 my ($self, $key, $setter, @args) = @_;
372 my $label = $self->{config}{labels}{$key} // ucfirst $key;
373 my %loc = %{ $self->{config}{locations} || {} };
374 my $locmsg = sprintf "Valid locations: %s\n", join(', ', sort keys %loc);
375 my $loc = $self->ask($label, 'home', sub {
376 return 1 if defined $loc{$_};
377 print STDERR $locmsg, "\n";
378 return undef;
379 });
380 $setter->($loc);
381 }
382  
383 sub ask {
384 my ($self, $label, $default, $validate) = @_;
385 if (!$self->{interactive}) {
386 return $default if defined $default;
387 return if $self->{unaskable};
388 die "$label Can't ask -- not running interactively";
389 }
390 else {
391 local $_;
392 while (1) {
393 my $cancelled;
394 local($SIG{INT}) = local($SIG{QUIT}) = local($SIG{TERM}) = sub {
395 $cancelled = 1;
396 };
397 print STDERR " $label: ";
398 print STDERR "[$default] " if defined $default;
399 $_ = <STDIN>;
400 if ($cancelled) {
401 print STDERR "\ncancelled\n";
402 $self->{running} = 0;
403 die;
404 }
405 chomp;
406 return $default if $_ eq '' && defined $default;
407 last if !$validate || $validate->();
408 }
409 return $_;
410 }
411 }
412  
413 sub instantiate {
414 my ($obj) = @_;
415 }
416  
417 sub placeholders {
418 my ($hash) = @_;
419 my @placeholders = _hash_placeholders($hash);
420 return map {
421 my $k = $_->[0];
422 $k => $_
423 } @placeholders;
424 }
425  
426 sub _hash_placeholders {
427 my ($hash, @path) = @_;
428 my @p;
429 while (my ($k, $v) = each %$hash) {
430 my $r = ref $v;
431 if ($r eq 'HASH') {
432 push @p, _hash_placeholders($v, ".$k");
433 }
434 elsif ($r eq 'ARRAY') {
435 push @p, _array_placeholders($v, "[$k]");
436 }
437 elsif ($r ne '') {
438 die "Huh???";
439 }
440 elsif ($v =~ /^<(.+)>$/) {
441 my $setter = sub { $hash->{$k} = shift };
442 my ($action, @args) = split /\s*:\s*/, $1;
443 push @p, [ join('', @path, ".$k"), $setter, $action, @args ];
444 }
445 }
446 return @p;
447 }
448  
449 1;
450  
451 =pod
452  
453 =head1 NAME
454  
455 Ei - manage an inventory of stuff
456  
457 =cut