File Coverage

lib/YAX/Element.pm

Criterion	Covered	Total	%
statement	69	107	64.4
branch	8	32	25.0
condition	1	3	33.3
subroutine	21	25	84.0
pod	12	17	70.5
total	111	184	60.3

package YAX::Element;

use strict;

use base qw/YAX::Node/;

use YAX;
use YAX::Query;
use YAX::Constants qw/ELEMENT_NODE/;

use Carp ();
use Scalar::Util qw/weaken/;

use overload
    '@{}' => \&children,
    '%{}' => \&attributes,
    '""'  => \&as_string,
    fallback => 1;

sub NAME () { 0 }
sub ATTR () { 1 }
sub KIDS () { 2 }
sub PRNT () { 3 }

sub new {
    my $class = shift;
    my ( $name, %atts ) = @_;
    my $self = bless \[ $name, \%atts, [ ] ], $class;
    $self;
}

sub type { ELEMENT_NODE() }

sub name {
    my $self = shift;
    $$self->[NAME] = shift if @_;
    $$self->[NAME];
}

sub clone {
    my $self = shift;
    my $deep = shift;
    my $copy = ref( $self )->new( $self->name, %$self );
    @$copy = map { $_->clone( $deep ) } @$self if $deep;
    return $copy;
}

sub query {
    my ( $self, $expr ) = @_;
    YAX::Query->new( $self )->select( $expr );
}

sub parent {
    my $self = shift;
    weaken( $$self->[PRNT] = $_[0] ) if @_;
    $$self->[PRNT];
}

sub children {
    my $self = shift;
    $$self->[KIDS];
}

sub attributes {
    my $self = shift;
    $$self->[ATTR];
}

sub append {
    my $self = shift;
    my $node = shift;
    if ( UNIVERSAL::isa( $node, 'YAX::Fragment' ) ) {
        $self->append( $_ ) for @$node;
    } else {
        push @$self, $self->adopt( $node );
    }
    $#$self;
}

sub replace {
    my ( $self, $new, $ref ) = @_;

    for ( my $x = 0; $x < @$self; $x++ ) {
        if ( $self->[$x] == $ref ) {
            if ( UNIVERSAL::isa( $new, 'YAX::Fragment' ) ) {
                splice( @$self, $x, 1, map { $self->adopt( $_) } @$new );
            } else {
                splice( @$self, $x, 1, $self->adopt( $new ) );
            }
            return $x;
        }
    }
}

sub remove {
    my ( $self, $chld ) = @_;
    return unless $chld->parent == $self;
    for ( my $x = 0; $x < @$self; $x++ ) {
        if ( $self->[$x] == $chld ) {
            splice( @$self, $x, 1 );
            $chld->parent( undef );
            return $x;
        }
    }
}

sub insert {
    my ( $self, $new, $ref ) = @_;

    unless ( defined $ref ) {
        if ( UNIVERSAL::isa( $new, 'YAX::Fragment' ) ) {
            unshift( @$self, map { $self->adopt( $_ ) } @$new );
        } else {
            unshift( @$self, $self->adopt( $new ) );
        }
        return 0;
    }

    for ( my $x = 0; $x < @$self; $x++ ) {
        if ( $self->[$x] == $ref ) {
            if ( UNIVERSAL::isa( $new, 'YAX::Fragment' ) ) {
                splice( @$self, $x, 0, map { $self->adopt( $_ ) } @$new );
            } else {
                splice( @$self, $x, 0, $self->adopt( $new ) );
            }
            return $x;
        }
    }
}

sub adopt {
    my ( $self, $node ) = @_;
    unless ( UNIVERSAL::isa( $node, 'YAX::Node' ) ) {
        Carp::croak( "cannot insert `$node' into the document tree" );
    }
    my $prnt = $node->parent;
    if ( defined $prnt and $prnt != $self ) {
        $prnt->remove( $node );
    }
    $node->parent( $self );
    return $node;
}

sub as_string {
    my $self = shift;
    my $name = $self->name;
    my $atts = $self->attributes_as_string;

    return "<$name $atts />" unless @{ $self->children };

    my $kids = $self->children_as_string;
    return "<$name".( $atts ? " $atts" : '' ).">".$kids."";
}

sub attributes_as_string {
    my $self = shift;
    return join(' ', map {
        $_.'="'.quote( $self->{$_} ).'"'
    } keys %$self);
}

sub children_as_string {
    my $self = shift;
    join( '', map { $_->as_string } @{ $self->children } );
}

sub quote {
    my $str = pop;
    $str =~ s/"/"/gs;
    $str;
}

1;
__END__