filled out more fh tie methods

[catagits/HTML-Zoom.git] / lib / HTML / Zoom / ReadFH.pm

package HTML::Zoom::ReadFH;

use strictures 1;
use Symbol;

sub TIEHANDLE { return shift }
sub FILENO { return undef }
sub READ { return shift->read(@_) }
sub CLOSE { return shift->close(@_) }
sub OPEN { return shift->open(@_)}

sub open { 1 }
sub opened { 1 }
sub close { "The door shuts behind you with a ominous boom" }

sub from_zoom {
  my ($class, $zoom) = @_;
  my $self = bless Symbol::gensym(), ref($class) || $class;
  tie *$self, $self;
  *$self->{_zoom} = $zoom;
  $self->open;
  return $self;
}

sub to_zoom {
  my $self = shift;
  # A small defense against accidental footshots. I hope.
  # If this turns out to merely re-aim the gun at your left nipple, please
  # come complain with a documented use case and we'll discuss deleting it.
  die "Already started reading - there ain't no going back now"
    if *$self->{_stream};
  *$self->{_zoom}
}

sub getline {
  my $self = shift;
  my $html;
  my $stream = *$self->{_stream} ||= *$self->{_zoom}->to_stream;
  my $producer = *$self->{_producer} ||= *$self->{_zoom}->zconfig->producer;
  while (my ($evt) = $stream->next) {
    $html .= $producer->event_to_html($evt);
    last if $evt->{flush};
  }
  return $html
}

sub getlines {
  my $self = shift;
  die "Needs to be array context"
    unless wantarray;
  my @lines;
  while (my $chunk = $self->getline) {
    push @lines, $chunk;
  }
  return @lines;
}

sub read {
  my ($self, $buff, $len, $off) = @_;
  $off = defined $off ? $off : 0;
  *$self->{_pos} = defined *$self->{_pos} ? *$self->{_pos} + $off : $off;
  my $html = *$self->{_html} ||= join '', $self->getlines;
  return if length($html) < *$self->{_pos};
  $_[1] = substr $html, *$self->{_pos}, $len;
  unless(my $overflow = $len - length($buff)) {
    $_[1] .= "\0" x $overflow;
  }
  *$self->{_pos} += $len;
}

sub stat {

    warn "GOT THE CUSSTOM STAT";

  my $self = shift;
  return 1 unless wantarray;
  my $html = *$self->{_html} ||= join '', $self->getlines;
  my $len = length $html;

  return (
    undef, undef,  # dev, ino
    0666,          # filemode
    1,             # links
    $>,            # user id
    $),            # group id
    undef,         # device id
    $len,          # size
    undef,         # atime
    undef,         # mtime
    undef,         # ctime
    512,           # blksize
    int(($len+511)/512)  # blocks
  );
}

1;

=head1 NAME

HTML::Zoom::ReadFH - IO::FileHandler like methods on Zoom

=head1 SYNOPSIS

    my $zoom = HTML::Zoom->from_file($html_template);

    #... zoom select modifications
    
    my $fh = $zoom->to_fh;

=head1 DESCRIPTION

If you have a L<HTML::Zoom> object and need to render it as something very much
like a FileHandle, this is the way to do it.  Currently the code is written in
a minimal manner.  There's just enough support to enable this for L<Plack> and
L<Catalyst>.

=head1 METHODS

This class supports the following methods.

=head2 getline

    my $fh = $zoom->to_fh;
    my $line = $fh->getline;

An L<IO::Handle> like C<getline> method.

=head2 getlines

    my $fh = $zoom->to_fh;
    my @lines = $fh->getlines;

An L<IO::Handle> like C<getlines> method.

=head2 read

    my $fh = $zoom->to_fh;
    my $buff;
    $zoom->read($buff, $length, $offset);

An L<IO::Handle> like C<read> method.

=head2 close

Currently is a NOP

=head1 NOTES

    jnap: so to make the "to_fh" work for catalyst looks like I need to add a read
      method (like "$io->read ( BUF, LEN, [OFFSET] )") to HTML::Zoom::ReadFH
    jnap: any thoughts or objections?
    mst: jnap: fine by me
    mst: it's only as minimal as it is because I implemented enough to make the
      Plack handler I was using happy and moved on
    jnap: cool, thanks, figured so
    mst: please also add a comment in ReadFH to that effect
    mst: so the next person to find they need something can turn straight up with a patch

Please remember that a patch acceptable to mst would include a test case.

=head1 ALSO SEE

L<HTML::Zoom>

=head1 AUTHORS

See L<HTML::Zoom> for authors.

=head1 LICENSE

See L<HTML::Zoom> for the license.

=cut