brennen
/
wrt


								package App::WRT::Renderer;


								use strict;

								use warnings;

								use 5.10.0;


								use Carp;

								use File::Basename;


								=pod


								=head1 NAME


								App::WRT::Renderer - render a wrt repo to publishable HTML


								=head1 SYNOPSIS


								    use App::WRT;

								    use App::WRT::Renderer;


								    my $wrt = App::WRT::new_from_file($config_file);

								    my $renderer = App::WRT::Renderer->new(

								      $wrt,

								      sub { say $_[0]; }

								    );


								    $renderer->render();


								=head1 METHODS


								=over


								=item new($class, $entry_dir, $logger, $io)


								Get a new Renderer.  Takes an instance of App::WRT, a logging callback, and a

								App::WRT::FileIO or similar object to be used for the actual intake and

								mangling of things on the filesystem.


								=cut


								sub new {

								  my $class = shift;

								  my ($wrt, $logger, $io) = @_;


								  ref($logger) eq 'CODE' or

								    croak("Error: Renderer expects an anonymous function for logging");


								  my %params = (

								    wrt    => $wrt,

								    logger => $logger,

								    io     => $io,

								  );


								  my $self = \%params;

								  bless $self, $class;

								}


								=item write($path, $contents)


								Write $contents to $path, using the FileIO object passed into the constructor

								above.


								=cut


								sub write {

								  my ($self, $file, $contents) = @_;

								  $self->{io}->file_put_contents($file, $contents)

								}


								=item render($class, $entry_dir)


								Render entries to F<publish_dir>.


								=cut


								sub render {

								  my $self = shift;


								  my $entry_dir = $self->{wrt}->{entry_dir};

								  my $publish_dir = $self->{wrt}->{publish_dir};


								  # Ensure that publication path exists and is a directory:

								  if (-e $publish_dir) {

								    unless (-d $publish_dir) {

								      croak("$publish_dir exists but is not a directory");

								    }

								  } else {

								    $self->log("Attempting to create $publish_dir");

								    unless ($self->dir_make_logged($publish_dir)) {

								      croak("Could not create $publish_dir");

								    }

								  }


								  # Handle the front page.  With no entries given, display() will use the

								  # configured default, which is probably "new" unless the user has changed it.

								  $self->write(

								    "${publish_dir}/index.html",

								    $self->{wrt}->display()

								  );


								  # Handle feed formats:

								  my $feed_alias = $self->{wrt}->{feed_alias};

								  my $xml_feed_content = $self->{wrt}->feed_print_recent();

								  my $json_feed_content = $self->{wrt}->feed_print_json_recent();

								  $self->write("${publish_dir}/${feed_alias}", $xml_feed_content);

								  $self->write("${publish_dir}/${feed_alias}.xml", $xml_feed_content);

								  $self->write("${publish_dir}/${feed_alias}.json", $json_feed_content);


								  # Handle any other paths that aren't derived directly from files:

								  my @meta_paths = qw(all);


								  my $rendered_count = 0;

								  my $copied_count   = 0;

								  for my $target ($self->{wrt}->{entries}->all(), @meta_paths)

								  {

								    # Skip index files - these are the text content of an entry, not

								    # a sub-entry:

								    next if $target =~ m{/index$};


								    # Lowercase and alphanumeric + underscores + dashes, no dots - an entry:

								    if ($self->{wrt}->{entries}->is_renderable($target)) {

								      $self->dir_make_logged("$publish_dir/$target");


								      my $rendered = $self->{wrt}->display($target);


								      my $target_file = "$publish_dir/$target/index.html";

								      $self->log("[write] $target_file " . length($rendered));

								      $self->write($target_file, $rendered);

								      $rendered_count++;

								      next;

								    }


								    # A directory - no-op:

								    if (-d "$entry_dir/$target") {

								      $self->log("[directory] $entry_dir/$target");

								      next;

								    }


								    # Some other file - a static asset of some kind:

								    my $dirname = dirname($target);

								    $self->log("[copy] archives/$target -> $publish_dir/$target");

								    $self->dir_make_logged("$publish_dir/$dirname");

								    $self->{io}->file_copy("$entry_dir/$target", "$publish_dir/$target");

								    $copied_count++;

								  }


								  $self->log("rendered $rendered_count entries");

								  $self->log("copied $copied_count static files");


								  # Presumed success:

								  return 1;

								}


								=item dir_make_logged($path)


								Make a directory path or log an error.


								=cut


								sub dir_make_logged {

								  my ($self, $path) = @_;

								  my $path_err;

								  $self->log("[create] $path");

								  $self->{io}->dir_make($path);

								  # XXX: surface these somehow

								  # $self->log(Dumper($path_err)) if @{ $path_err };

								}


								=item log(@log_items)


								Call logging callback with passed parameters.


								=cut


								sub log {

								  my ($self) = shift;

								  $self->{logger}->(@_);

								}


								=back


								=cut


								1;