XML-Handler-ExtOn

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

    - add_namespace to ExtOn
    - add delete alias
    
0.04
    - add SAX1 to ExtOn converter 
0.03
    - add tests
    - documenting
    - get attrs by name ( by_name )
0.02 
    - add mk_characters and mk_cdata
    - add on_cdata

MANIFEST  view on Meta::CPAN

lib/XML/Handler/ExtOn/TieAttrsName.pm
Makefile.PL
MANIFEST
README
t/008_PSAX::TieAttrs.t
t/009_ExtOn::Attributes.t
t/009_ExtOn::Context.t
t/010_Element.t
t/050.t
t/060_ExtOn_skip_root.t
t/070_characters_cdata.t
t/080_create_pipe.t
META.yml

lib/XML/Handler/ExtOn.pm  view on Meta::CPAN

=item * on_start_document

=item * on_start_prefix_mapping

=item * on_start_element

=item * on_end_element

=item * on_characters

=item * on_cdata

=back

XML::Handler::ExtOn  put all B<cdata> characters into a single event C<on_cdata>.

It compliant XML namespaces (http://www.w3.org/TR/REC-xml-names/), by support 
I<default namespace> and I<namespace scoping>.

XML::Handler::ExtOn provide methods for create XML, such as C<mk_element>, C<mk_cdata> ...

=head1 FUNCTIONS

=cut

use strict;
use warnings;

use Carp;
use Data::Dumper;

lib/XML/Handler/ExtOn.pm  view on Meta::CPAN

            
        }
    }
    return $out_handler;
}

use base 'XML::SAX::Base';
use vars qw( $AUTOLOAD);
$XML::Handler::ExtOn::VERSION = '0.06';
### install get/set accessors for this object.
for my $key (qw/ context _objects_stack _cdata_mode _cdata_characters/) {
    no strict 'refs';
    *{ __PACKAGE__ . "::$key" } = sub {
        my $self = shift;
        $self->{___EXT_on_attrs}->{$key} = $_[0] if @_;
        return $self->{___EXT_on_attrs}->{$key};
      }
}

=head1 METHODS

=cut

sub new {
    my $class = shift;
    my $self = &XML::SAX::Base::new( $class, @_, );
    $self->_objects_stack( [] );
    $self->_cdata_mode(0);
    my $buf;
    $self->_cdata_characters( \$buf );    #setup cdata buffer
    my $doc_context = new XML::Handler::ExtOn::Context::;
    $self->context($doc_context);
    return $self;
}

=head2 on_start_document $document

Method handle C<start_document> event. Usually override for initialaize default
variables.

lib/XML/Handler/ExtOn.pm  view on Meta::CPAN

Method handle C<on_start_element> event whith XML::Handler::ExtOn::Element object.

Method must return C<$elem> or ref to array of objects.

For example:

    sub on_start_element {
        my $self = shift;
        my $elem = shift;
        $elem->add_content( $self->mk_cdata("test"));
        return $elem
    }
    ...
    
    return [ $elem, ,$self->mk_element("after_start_elem") ]
    
    return [ $self->mk_element("before_start_elem"), $elem ]
    ...

=cut

lib/XML/Handler/ExtOn.pm  view on Meta::CPAN

    }


=cut

sub on_characters {
    my ( $self, $elem, $str ) = @_;
    return $str;
}

=head2 on_cdata ( $current_element, $data )

Must return string for write to stream

    sub on_cdata {
        my ( $self, $elem, $str ) = @_;
        return lc $str;
    }

=cut

sub on_cdata {
    my ( $self, $elem, $str ) = @_;
    return $str;
}

#set flag for cdata content

sub start_cdata {
    my $self = shift;
    $self->_cdata_mode(1);
    return;
}

#set flag to end cdata

sub end_cdata {
    my $self = shift;
    if ( my $elem = $self->current_element
        and defined( my $cdata_buf = ${ $self->_cdata_characters } ) )
    {
        if ( defined( my $data = $self->on_cdata( $elem, $cdata_buf ) ) ) {
            $self->SUPER::start_cdata;
            $self->SUPER::characters( { Data => $data } );
            $self->SUPER::end_cdata;
        }
    }

    #after all clear cd_data_buffer and reset cd_data mode flag
    my $new_buf;
    $self->_cdata_characters( \$new_buf );
    $self->_cdata_mode(0);
    return;
}

sub characters {
    my $self = shift;
    my ($data) = @_;
#skip childs elements characters ( > 1 ) and self text ( > 0)
#    warn $self.Dumper([ map {[caller($_)]} (1..10)]) unless $self->current_element;
    if ( $self->current_element ) {
        return if $self->current_element->is_skip_content;
    }
    else {

        #skip characters without element
        return

          #        #warn "characters without element"
    }

    #for cdata section collect characters in buffer
    if ( $self->_cdata_mode ) {
        ${ $self->_cdata_characters } .= $data->{Data};
        return;
    }

    #collect chars fo current element
    if (
        defined(
            my $str =
              $self->on_characters( $self->current_element, $data->{Data} )
        )
       )

lib/XML/Handler/ExtOn.pm  view on Meta::CPAN

    my $sax2_filter = XML::Filter::SAX1toSAX2->new( Handler => $skip_tmp_root );
    my $parser      = XML::Parser::PerlSAX->new(
        {
            Handler => $sax2_filter,
            Source  => { String => "<tmp>$string</tmp>" }
        }
    );
    return $parser;
}

=head2 mk_cdata $string | \$string

return command for insert cdata to stream

=cut

sub mk_cdata {
    my $self   = shift;
    my $string = shift;
    return { type => 'CDATA', data => ref($string) ? $string : \$string };
}

=head2 mk_characters $string | \$string

return command for insert characters to stream

=cut

lib/XML/Handler/ExtOn.pm  view on Meta::CPAN

    elsif ( UNIVERSAL::isa( $comm, 'XML::Handler::ExtOn::Element' ) ) {
        $self->start_element($comm);

        while ( my $obj = shift @{ $comm->_stack } ) {
            $self->_process_comm($obj);
        }
        $self->end_element($comm);
    }
    elsif ( ref($comm) eq 'HASH' and exists $comm->{type} ) {
        if ( $comm->{type} eq 'CDATA' ) {
            $self->start_cdata;
            $self->characters( { Data => ${ $comm->{data} } } );
            $self->end_cdata;
        }
        elsif ( $comm->{type} eq 'CHARACTERS' ) {
            $self->characters( { Data => ${ $comm->{data} } } );
        }
    }
    else {
        warn " Unknown DATA $comm";
    }
}

lib/XML/Handler/ExtOn/Element.pm  view on Meta::CPAN

    my $self = shift;
    $self->{__name} = shift || return $self->{__name};
}

=head2 add_content <element object1>[, <element object2> ...]

Add commands to contents stack.Return C<$self>

    $elem->add_content( 
        $self->mk_from_xml("<p/>"),
        $self->mk_cdata("TEST CDATA"),
        )

=cut

sub add_content {
    my $self = shift;
    push @{$self->_stack()}, @_;
    return $self
}

t/070_characters_cdata.t  view on Meta::CPAN

    my $psax_filter = $name->new( Handler           => $w1 );
    return $psax_filter, \$str1;
}

my $str;
my ( $filter, $res ) = create_parser_no_parse('MyHandler1');
$filter->start_document;
my $s_elem =
  $filter->mk_element("a")
  ->add_content( $filter->mk_from_xml("<p/>"),
    $filter->mk_cdata(\"00000"), $filter->mk_characters("**"));
$filter->start_element($s_elem);
$filter->start_cdata( );
$filter->characters( { Data => "asdasdad" } );
$filter->end_cdata();
$filter->end_element();
$filter->end_document;
is ( '00000asdasdad', $filter->{CDTAAAA}, 'test cd_data');
is ( '**', $filter->{CHARS}, 'test characters');
#diag $$res;
#diag $filter->{CDTAAAA};
exit;

package MyHandler1;
use base 'XML::Handler::ExtOn';
use strict;
use warnings;

sub on_start_element {
    my ( $self, $elem ) = @_;

    return $elem;
}
sub on_cdata {
    my $self = shift;
    my $elem = shift;
    my $string = shift;
    $self->{CDTAAAA} .= $string;
    return $string
}
sub on_characters {
    my $self = shift;
    my $elem = shift;
    my $string = shift;