| 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 |