XML-Toolkit

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

lib/XML/Toolkit/MetaDescription/Attribute.pm
lib/XML/Toolkit/MetaDescription/Trait.pm
lib/XML/Toolkit/Trait/NoXML.pm
t/00-compile.t
t/01.basic.t
t/02.namespaces/01.basic_namespace.t
t/02.namespaces/02.root_namespace_equality.t
t/02.namespaces/03.namespaced_loading.t
t/03.xspf.t
t/04.rdf.t
t/05.cdata.t
t/06.reuse/06.reuse_generator.t
t/06.reuse/06.reuse_loader.t
t/release-pod-coverage.t
t/release-pod-syntax.t

lib/XML/Filter/Moose.pm  view on Meta::CPAN

    isa       => 'Str',
    is        => 'rw',
    traits    => ['String'],
    lazy      => 1,
    clearer   => 'reset_text',
    predicate => 'has_text',
    default   => sub { '' },
    handles   => { append_text => 'append', },
);

has cdata => ( isa => 'Bool', is => 'rw', );

sub is_root { return shift->stack_length == 0 }

sub parent_element {
    my ($self) = @_;
    if ( $self->stack_length > 1 ) {
        return $self->stack->[-1];
    }
    $self->root;
}

lib/XML/Generator/Moose.pm  view on Meta::CPAN

sub characters {
    my ( $self, $data ) = @_;
    $self->Handler->characters( { Data => $data } );
}

sub newline {
    my $self = shift;
    $self->Handler->characters( { Data => "\n" } );
}

sub cdata {
    my ( $self, $data ) = @_;
    $self->start_cdata();
    $self->Handler->characters( { Data => $data } );
    $self->end_cdata();
}

sub start_prefix_mapping {
    my ( $self, $prefix, $uri ) = @_;
    $self->Handler->start_prefix_mapping(
        { Prefix => $prefix, NamespaceURI => $uri } );
}

sub end_prefix_mapping {
    my ( $self, $prefix ) = @_;

lib/XML/Generator/Moose.pm  view on Meta::CPAN

=over

=item start_element

=item end_element

=item characters

=item newline

=item cdata

=item parse

=back

See Also XML::SAX::Base

=head1 INCOMPATIBILITIES

None reported.

lib/XML/Toolkit/Builder/Filter.pm  view on Meta::CPAN

sub add_text_attribute {
    my ( $self, $class ) = @_;
    $class->add_attribute(
        'text' => (
            isa         => 'Str',
            is          => 'rw',
            traits      => [XMLTrait],
            description => {
                node_type => 'character',
                cdata     => $self->cdata,
            },
        )
    );
}

sub start_cdata {
    my ( $self, $el ) = @_;
    $self->cdata(1);
}

sub end_cdata {
    my ( $self, $el ) = @_;
#    $self->cdata(0);
}

sub start_element {
    my ( $self, $el ) = @_;

    my $classname = $self->get_class_name($el);

    $el->{classname} = $classname;

    my $class = $self->create_class( $classname => $el );

lib/XML/Toolkit/Generator/Default.pm  view on Meta::CPAN

    return 0;
}

sub is_text_node {
    my ( $self, $attr ) = @_;
    return 0 unless $self->is_node($attr);
    return 1 if $attr->description->{node_type} eq 'character';
    return 0;
}

sub is_cdata_node {
    my ( $self, $attr ) = @_;
    return 0 unless $self->is_node($attr);
    return 1 if $attr->description->{cdata};
    return 0;
}

sub is_attribute_node {
    my ( $self, $attr ) = @_;
    return 0 unless $self->is_node($attr);
    return 1 if $attr->description->{node_type} eq 'attribute';
    return 0;
}

lib/XML/Toolkit/Generator/Default.pm  view on Meta::CPAN

    my $name = $descr->{Name};

    $self->start_element(
        $name => \%attrs,
        $descr,
    );

    for my $attr ( $self->_get_sorted_filtered_attributes($meta) ) {
        if ( $self->is_text_node($attr) ) {
            my $data = $attr->get_value($obj);
            $self->is_cdata_node($attr)
              ? $self->cdata($data)
              : $self->characters($data);
        }
        elsif ( $self->is_child_node($attr) ) {
            next unless my $value = $attr->get_value($obj);
            for my $child ( grep { defined } @$value ) {
                next unless blessed $child;
                $self->parse_object( $child->meta, $child, $attr->description );
            }
        }
        else { warn "${\$attr->dump} is funky" }