dtRdr::Library::YAMLLibrary - a library in yaml

  dtRdr::Library::YAMLLibrary->create($file);

  my $library = dtRdr::Library::YAMLLibrary->new();

  $library->load_uri($uri);

  $self->_dumpload;

  $self->_dump;

  $self->_load;

  $self->_setup_info;

  $lib->set_id($id);

  $lib->set_name($name);

  $lib->set_storage($storage);

  $id = $library->add_book(
    book_id => $id,
    title   => $title,
    uri     => $uri,
    type    => $type
  );

  my $value = $library->get_info($key);

  $library->set_info($key, $value);

  $info = $lib->find_book_by($key, $value);

  $self->book_data;

package dtRdr::Library::YAMLLibrary;
$VERSION = eval{require version}?version::qv($_):$_ for(0.0.1);


use warnings;
use strict;
use Carp;

use base 'dtRdr::Library';
use dtRdr::Library (
  register => {
    type => 'YAMLLibrary'
  },
);
sub LIBTYPE {'YAMLLibrary';} # needs to go away when plugins work?
sub CORE_ATTRIBS {qw(name type id);}

use Class::Accessor::Classy;
no  Class::Accessor::Classy;

use YAML::Syck qw(
  LoadFile
  DumpFile
);

use File::Basename qw(
  dirname
);

sub create {
  my $package = shift;
  my $file = shift;
  $file or croak("must have a filename");
  (@_ % 2) and croak('odd number of elements in argument list');
  my (%args) = @_;

  my $id = exists($args{id}) ? $args{id} : '_setme_';

  my %data = (
    library_info => {
      id      => $id,
      type    => $package->LIBTYPE,
      version => $package->VERSION . '', # ensure stringification
    },
    books => [
    ],
  );
  DumpFile($file, \%data);
} # end subroutine create definition
########################################################################
sub _ylibrary_info { $_[0]->{yml}{library_info};}
sub _ybooks        { $_[0]->{yml}{books};}

# XXX who said I needed this?
# sub new {
#   my $package = shift;
#   my $class = ref($package) || $package;
#   my $self = {};
#   bless($self, $class);
#   return($self);
# } # end subroutine new definition
# ########################################################################

sub load_uri {
  my $self = shift;
  my ($file) = @_;

  (-e $file) or croak("cannot find library file '$file'");
  $self->{location} = $file;
  $self->_load;
  $self->_setup_info;

} # end subroutine load_uri definition
########################################################################

sub _dumpload {
  my $self = shift;
  $self->_dump;
  $self->_load;
} # end subroutine _dumpload definition
########################################################################

sub _dump {
  my $self = shift;
  DumpFile($self->location, $self->{yml});
} # end subroutine _dump definition
########################################################################

sub _load {
  my $self = shift;
  $self->{yml} = LoadFile($self->location);
} # end subroutine _load definition
########################################################################

sub _setup_info {
  my $self = shift;

  my $L = $self->_ylibrary_info;
  # TODO check $L->{version};
  foreach my $key ($self->CORE_ATTRIBS) {
    $self->{$key} = $L->{$key} if(exists($L->{$key}));
  }

  my $dir = dirname($self->location);
  # TODO allow absolute path?
  my $storage = exists($L->{storage}) ? ('/' . $L->{storage}) : '';
  $self->{directory} = (defined($dir) ? $dir : '.') . $storage;
} # end subroutine _setup_info definition
########################################################################

sub set_id {
  my $self = shift;
  my ($id) = @_;

  my $L = $self->_ylibrary_info;
  ($L->{id} eq '_setme_') or
    croak("the library's id is locked: '$L->{id}'");
  $L->{id} = $self->{id} = $id;
  $self->_dumpload;
} # end subroutine set_id definition
########################################################################

sub set_name {
  my $self = shift;
  my ($name) = @_;

  my $L = $self->_ylibrary_info;
  $L->{name} = $self->{name} = $name;
  $self->_dumpload;
} # end subroutine set_name definition
########################################################################

sub set_storage {
  my $self = shift;
  my ($sdir) = @_;

  my $L = $self->_ylibrary_info;
  my $checkdir = dirname($self->location) . '/' . $sdir;
  (-e $checkdir) or
    croak("cannot set a non-existent path ($checkdir) ",
      "as the storage directory");
  $L->{storage} = $sdir;
  $self->_dumpload;
  $self->_setup_info;
} # end subroutine set_storage definition
########################################################################

sub add_book {
  my $self = shift;
  (@_ % 2) and croak('odd number of elements in argument list');
  my (%data) = @_;

  my $B = $self->_ybooks;
  if(defined(my $id = delete($data{id}))) {
    ($id == @$B) or croak("cannot use id '$id'");
  }
  my $v = push(@$B, \%data) - 1;

  $self->_dumpload;
  return($v);
} # end subroutine add_book definition
########################################################################

# XXX these two should go away {{{

sub get_info {
  my $self = shift;
  my ($key) = @_;

  my $L = $self->_ylibrary_info;
  return($L->{$key});
} # end subroutine get_info definition
########################################################################

sub set_info {
  my $self = shift;
  my ($key, $value) = @_;

  my $L = $self->_ylibrary_info;
  $L->{$key} = $value;

  $self->_dumpload;
} # end subroutine set_info definition
########################################################################
# XXX these two should go away }}}

sub find_book_by {
  my $self = shift;
  my ($key, $value) = @_;

  my $B = $self->book_data;
  my @books = grep({$_->{$key} eq $value} @$B);
  return(@books);
} # end subroutine find_book_by definition
########################################################################

sub book_data {
  my $self = shift;

  my $B = $self->_ybooks;
  # TODO make those persistent objects
  return([map({
    dtRdr::LibraryData::BookInfo->new(%{$B->[$_]},
      intid => $_, library => $self
    )
  } 0..$#$B)]);
} # end subroutine book_data definition
########################################################################

# vi:ts=2:sw=2:et:sta
1;