gistfile1.txt

package OFP::Asset;
use Mojo::Base -strict, -signatures;

use Mojo::Collection qw(c);
use Mojo::File;

has [qw(fat oat)];
has [qw(core sup partner sil1 sil2 sil3)];
has warnings => sub { Mojo::Collection->new };

sub add_file ($self, $path) {
  my $basename = Mojo::File->new($path)->basename;
  return unless scalar grep { defined $self->$_ && $self->$_ eq $basename } qw(jp fileid filename);
  my $asset = Mojo::Asset::File->with_roles('+OFP::File')->new(path => $path) or return;
  return unless $asset->is(jp => $self->jp) || $asset->is(fileid => $self->fileid) || $asset->is(filename => $self->filename);
  my $from = $asset->from;
  return if $self->$from;
  $self->$from($asset) if $from;
}

sub get ($self, $field) {
  my $value = c(map { ref $self->$_ ? [$_ => $self->$_->$field] : undef } qw(fat oat core sup partner sil1 sil2 sil3))
    ->grep(sub { defined $_ })
    ->uniq;
  return $value->first->[1] if $value->size == 1;
  warn "Multiple values for $field: " . $value->map(sub { "$_->[0]:$_->[1]" })->join(', ') if $value->size > 1;
  return undef;
}

sub jp ($self) { $self->get('jp') }
sub fileid ($self) { $self->get('fileid') }
sub filename ($self) { $self->get('filename') }
sub file ($self) { $self->get('file') }
sub dmm_filename ($self) { $self->get('dmm_filename') }
sub host_filename ($self) { $self->get('host_filename') }
sub crc ($self) { $self->get('crc') }
sub ccs ($self) { $self->get('ccs') }

1;

package Mojo::Asset::File::Role::OFP::File;
use Mojo::Base -role, -signatures;
use overload '""' => sub { shift->to_string }, fallback => 1;

use Digest::SHA;
use Mojo::Collection;
use Mojo::File;
use Mojo::Util;

has simple_path => undef;

has fileid => undef;
has filename => undef;
has jp => undef;

has from_core => undef;
has from_sup => undef;
has from_partner => undef;
has from_sil1 => undef;
has from_sil2 => undef;
has from_sil3 => undef;

has on_pc => undef;
has on_disk1 => undef;
has on_disk2 => undef;

has warnings => sub { Mojo::Collection->new };

sub from ($self) {
  return 'core' if $self->from_core;
  return 'sup' if $self->from_sup;
  return 'partner' if $self->from_partner;
  return 'sil1' if $self->from_sil1;
  return 'sil2' if $self->from_sil2;
  return 'sil3' if $self->from_sil3;
  return undef;
}

sub from_sil ($self) { $self->from_sil1 || $self->from_sil2 || $self->from_sil3 };

sub file ($self) { $self->fileid ? sprintf 'ABCD%04d.XYZ', $self->fileid : undef }

sub flip_sum ($self) {
  my $path = Mojo::File->new($self->path);
  my $sum_file = $path->sibling(sprintf '.%s.flip_sum', $path->basename);
  return $sum_file->slurp if -s $sum_file;

  my $sha1 = Digest::SHA->new(1);

  open my $fh, '<:raw', $self->path or die qq{Could not open "@{[$self->path]}": $!};

  my $size = -s $fh;

  while ($size > 0) {
    my $read_size = $size >= 4 ? 4 : $size;
    $size -= $read_size;

    seek $fh, $size, 0 or die qq{Could not seek in "@{[$self->path]}": $!};

    my $buffer;
    my $bytes_read = read $fh, $buffer, $read_size;
    die qq{Could not read from "@{[$self->path]}": $!} if !defined $bytes_read;
    die qq{Short read from "@{[$self->path]}"} if $bytes_read != $read_size;

    $sha1->add(scalar reverse $buffer);
  }

  close $fh or die qq{Could not close "@{[$self->path]}": $!};

  my $hexdigest = $sha1->hexdigest;
  $sum_file->spurt($hexdigest);
  return $hexdigest;
}

sub is ($self, $field, $value) { defined $self->$field && defined $value && $self->$field eq $value }
sub is_flip ($self, $sum) { $self->flip_sum eq $sum }
sub is_orig ($self, $sum) { $self->orig_sum eq $sum }
sub is_same ($self, $sum) { $self->is_flip($sum) || $self->is_orig($sum) }
sub ok ($self, $field) { defined $self->$field }

sub on ($self) {
  return 'pc' if $self->on_pc;
  return 'disk1' if $self->on_disk1;
  return 'disk2' if $self->on_disk2;
  return undef;
}

sub on_disk ($self) { $self->on_disk1 || $self->on_disk2 };

sub orig_sum ($self) {
  my $path = Mojo::File->new($self->path);
  my $sum_file = $path->sibling(sprintf '.%s.orig_sum', $path->basename);
  return $sum_file->slurp if -s $sum_file;
  my $sha1 = Mojo::Util::sha1_sum($path->slurp);
  $sum_file->spurt($sha1);
  return $sha1;
}

sub set_file ($self, $file) { $self->set_fileid($file) }
sub set_fileid ($self, $fileid) { defined $self->fileid and warn "FileID is already set" and push @{$self->warnings}, [fileid => $fileid] and return $self; $self->fileid(sprintf '%04s', $fileid =~ s/^(ABCD)?(\w{4})(\.XYZ)?$/$2/r); return $self }
sub set_filename ($self, $filename) { defined $self->filename and warn "Filename is already set" and push @{$self->warnings}, [filename => $filename] and return $self; $self->filename($filename); return $self }
sub set_jp ($self, $jp) { defined $self->jp and warn "JP is already set" and push @{$self->warnings}, [jp => $jp] and return $self; $self->jp($jp); return $self }

sub to_string ($self) {
  sprintf 'JP: %s, FileID: %s, File: %s, Filename: %s',
    defined $self->jp ? $self->jp : 'undef',
    defined $self->fileid ? $self->fileid : 'undef',
    defined $self->file ? $self->file : 'undef',
    defined $self->filename ? $self->filename : 'undef',
}

1;