view release on metacpan or  search on metacpan

lib/CSS/Object.pm  view on Meta::CPAN

        return( $self );
    }
    return( $self->error( "Only scalars and arrays accepted: $!" ) );
}

sub read_string
{
    my $self = shift( @_ );
    my $data = shift( @_ );

    if( ref( $data ) )
    {
        if( ref( $data ) eq 'ARRAY' )
        {
            for( @$data )
            {
                $self->read_string( $_ ) || return( $self->pass_error );
            }
            return( $self );
        }
    }
    elsif( length( $data ) )
    {
        my $elems = $self->parse_string( $data ) || return( $self->pass_error );
        ## $self->rules->push( @$rules );
        $self->elements->push( @$elems );
    }
    return( $self );
}

sub remove_rule
{
    my $self = shift( @_ );
    my $rule = shift( @_ );
    return( $self->error( "No rule object was provided to remove." ) ) if( !defined( $rule ) );
    return( $self->error( "Object provided is not a CSS::Object::Rule object." ) ) if( !$self->_is_a( $rule, 'CSS::Object::Rule' ) );
    $self->elements->remove( $rule );
    return( $self );
}

# sub rules { return( shift->_set_get_array_as_object( 'rules', @_ ) ); }
sub rules { return( $_[0]->elements->map(sub{ $_[0]->_is_a( $_, 'CSS::Object::Rule' ) ? $_ : () }) ); }

1;
# NOTE POD
__END__

=encoding utf-8

=head1 NAME

CSS::Object - CSS Object Oriented

=head1 SYNOPSIS

    use CSS::Object;
    use LWP::UserAgent;
    my $ua = LWP::UserAgent->new;
    my $resp = $ua->get( $style_uri );
    die( $resp->message ) if( $resp->is_error );
    my $style = $resp->decoded_content;
    my $css = CSS::Object->new;
    $css->read_string( $style );
    $css->rules->foreach(sub
    {
        my $rule = shift( @_ );
        # more processing
    });

or, parsing inline stylesheets from a remote document:

    use HTML::Object;
    use HTML::Object::XQuery;
    use LWP::UserAgent;
    my $ua = LWP::UserAgent->new;
    my $resp = $ua->get( $document_uri );
    die( $resp->message ) if( $resp->is_error );
    my $html = $resp->decoded_content;
    my $parser = HTML::Object->new;
    my $doc = $parser->parse( $html ) || die( $parser->error );
    my $styles = $doc->find( 'style' ) || die( $doc->error );
    say "Nothing found", exit(0) unless( $styles->length > 0 );
    my $data = $styles->children->first->text();
    my $css = CSS::Object->new;
    $css->read_string( $data );
    $css->rules->foreach(sub
    {
        my $rule = shift( @_ );
        # more processing
    });

Creating dynamically rules:

    use CSS::Object;
    my $css = CSS::Object->new ||
        die( CSS::Object->error );
    my $b = $css->builder;
    $b->select( ['#main_section > .article', 'section .article'] )
        ->display( 'none' )
        ->font_size( '+0.2rem' )
        ->comment( ['Some multiline comment', 'that are made possible with array reference'] )
        ->text_align( 'center' )
        ->comment( 'Making it look pretty' )
        ->padding( 5 );
    $b->charset( 'UTF-8' );
    $b->at( _webkit_keyframes => 'error' )
        ->frame( 0, { _webkit_transform => 'translateX( 0px )' })
        ->frame( 25, { _webkit_transform => 'translateX( 30px )' })
        ->frame( 45, { _webkit_transform => 'translateX( -30px )' })
        ->frame( 65, { _webkit_transform => 'translateX( 30px )' })
        ->frame( 82, { _webkit_transform => 'translateX( -30px )' })
        ->frame( 94, { _webkit_transform => 'translateX( 30px )' })
        ->frame( [qw( 35 55 75 87 97 100 )], { _webkit_transform => 'translateX( 0px )' } );
    say $css->as_string;

=head1 VERSION

    v0.2.0

=head1 DESCRIPTION

L<CSS::Object> is a object oriented CSS parser and manipulation interface.

=head1 CONSTRUCTOR

=head2 new

To instantiate a new L<CSS::Object> object, pass an hash reference of following parameters:

=over 4

=item I<debug>

This is an integer. The bigger it is and the more verbose is the output.

=item I<format>

This is a L<CSS::Object::Format> object or one of its child modules.