add .gitignore file

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

diff --git a/lib/HTML/Zoom/FilterBuilder.pm b/lib/HTML/Zoom/FilterBuilder.pm
index dc03958..0d4be1a 100644 (file)
--- a/lib/HTML/Zoom/FilterBuilder.pm
+++ b/lib/HTML/Zoom/FilterBuilder.pm
@@ -1,7 +1,5 @@
 package HTML::Zoom::FilterBuilder;
 
-use Devel::Dwarn;
-
 use strict;
 use warnings FATAL => 'all';
 use HTML::Zoom::CodeStream;
@@ -17,20 +15,24 @@ sub _stream_from_array {
   HTML::Zoom::CodeStream->from_array(@_)
 }
 
+sub _stream_from_proto {
+  my ($self, $proto) = @_;
+  my $ref = ref $proto;
+  if (not $ref) {
+    return $self->_stream_from_array({ type => 'TEXT', raw => $proto });
+  } elsif ($ref eq 'ARRAY') {
+    return $self->_stream_from_array(@$proto);
+  } elsif ($ref eq 'CODE') {
+    return $proto->();
+  } elsif ($ref eq 'SCALAR') {
+    require HTML::Zoom::Parser::BuiltIn;
+    return HTML::Zoom::Parser::BuiltIn->html_to_stream($$proto);
+  }
+  die "Don't know how to turn $proto (ref $ref) into a stream";
+}
+
 sub _stream_concat {
-  shift; # lose $self
-  my @streams = @_;
-  my $cur_stream = shift(@streams) or die "No streams passed";
-  HTML::Zoom::CodeStream->new({
-    code => sub {
-      return unless $cur_stream;
-      my $evt;
-      until (($evt) = $cur_stream->next) {
-        return unless $cur_stream = shift(@streams);
-      }
-      return $evt;
-    }
-  });
+  shift->_stream_from_array(@_)->flatten;
 }
 
 sub set_attribute {
@@ -85,7 +87,13 @@ sub collect {
   my ($into, $passthrough, $inside) = @{$options}{qw(into passthrough inside)};
   sub {
     my ($evt, $stream) = @_;
-    push(@$into, $evt) if $into && !$inside;
+    # We wipe the contents of @$into here so that other actions depending
+    # on this (such as a repeater) can be invoked multiple times easily.
+    # I -suspect- it's better for that state reset to be managed here; if it
+    # ever becomes painful the decision should be revisited
+    if ($into) {
+      @$into = $inside ? () : ($evt);
+    }
     if ($evt->{is_in_place_close}) {
       return $evt if $passthrough || $inside;
       return;
@@ -122,10 +130,11 @@ sub add_before {
 
 sub add_after {
   my ($self, $events) = @_;
+  my $coll_proto = $self->collect({ passthrough => 1 });
   sub {
     my ($evt) = @_;
     my $emit = $self->_stream_from_array(@$events);
-    my $coll = $self->collect({ passthrough => 1 })->(@_);
+    my $coll = &$coll_proto;
     return ref($coll) eq 'HASH' # single event, no collect
       ? [ $coll, $emit ]
       : [ $coll->[0], $self->_stream_concat($coll->[1], $emit) ];
@@ -148,6 +157,7 @@ sub prepend_inside {
 
 sub append_inside {
   my ($self, $events) = @_;
+  my $coll_proto = $self->collect({ passthrough => 1, inside => 1 });
   sub {
     my ($evt) = @_;
     if ($evt->{is_in_place_close}) {
@@ -156,27 +166,49 @@ sub append_inside {
         @$events, { type => 'CLOSE', name => $evt->{name} }
       ) ];
     }
-    my $coll = $self->collect({ passthrough => 1, inside => 1 })->(@_);
+    my $coll = &$coll_proto;
     my $emit = $self->_stream_from_array(@$events);
     return [ $coll->[0], $self->_stream_concat($coll->[1], $emit) ];
   };
 }
 
 sub replace {
-  my ($self, $events, $options) = @_;
+  my ($self, $replace_with, $options) = @_;
+  my $coll_proto = $self->collect($options);
   sub {
     my ($evt, $stream) = @_;
-    my $emit = $self->_stream_from_array(@$events);
-    my $coll = $self->collect($options)->(@_);
+    my $emit = $self->_stream_from_proto($replace_with);
+    my $coll = &$coll_proto;
+    # For a straightforward replace operation we can, in fact, do the emit
+    # -before- the collect, and my first cut did so. However in order to
+    # use the captured content in generating the new content, we need
+    # the collect stage to happen first - and it seems highly unlikely
+    # that in normal operation the collect phase will take long enough
+    # for the difference to be noticeable
     return
       ($coll
         ? (ref $coll eq 'ARRAY'
-            ? [ $coll->[0], $self->_stream_concat($emit, $coll->[1]) ]
-            : $self->_stream_concat($emit, $coll)
+            ? [ $coll->[0], $self->_stream_concat($coll->[1], $emit) ]
+            : $self->_stream_concat($coll, $emit)
           )
         : $emit
       );
   };
 }
 
+sub repeat {
+  my ($self, $repeat_for, $options) = @_;
+  $options->{into} = \my @into;
+  my $map_repeat = sub {
+    local $_ = $self->_stream_from_array(@into);
+    $_[0]->($_)
+  };
+  my $repeater = sub {
+    $self->_stream_from_proto($repeat_for)
+         ->map($map_repeat)
+         ->flatten
+  };
+  $self->replace($repeater, $options);
+}
+
 1;