File Coverage

blib/lib/CSS/Moonfall.pm

Criterion	Covered	Total	%
statement	93	98	94.9
branch	30	36	83.3
condition	2	3	66.6
subroutine	25	25	100.0
pod	2	2	100.0
total	152	164	92.6

package CSS::Moonfall;
use strict;
use warnings;
use base 'Exporter';
use Text::Balanced 'extract_bracketed';

our @EXPORT = qw/filter fill/;
our $VERSION = '0.04';

sub filter {
    my $package = shift;
    my $in = shift;
    my $out = '';

    while (length $in) {
        ((my $extracted), $in, my $prefix)
            = extract_bracketed($in, '[q]', '[^\[]+');
        return $out . $in if !defined($extracted);
        $out .= $prefix;

        # get rid of the []
        substr($extracted, -1, 1, '');
        substr($extracted, 0, 1, '');

        # get the rest of the line around the extracted text so we can check
        # how much we should indent, and whether to compress the output into
        # one line
        my ($preline)  = $prefix =~ /(.*)$/;
        my ($postline) = $in     =~ /^(.*)/;

        $out .= _process($package, $extracted, 1, $preline, $postline);
    }

    return $out;
}

sub fill {
    my $values = shift;
    my $total = delete $values->{total} or do {
        require Carp;
        Carp::croak "You must define a total size in a call to fill.";
    };

    my $unfilled = 0;

    for my $k (keys %$values) {
        if (defined(my $w = $values->{$k})) {
            $total -= $w;
        }
        else {
            ++$unfilled;
        }
    }

    $total = int($total / $unfilled);

    for (values %$values) {
        defined or $_ = $total;
    }

    return $values;
}

# this is where all the logic of expanding [foo] into some arbitrary string is
sub _process {
    my $package = shift;
    my $in      = shift;
    my $top     = shift;
    my $pre     = shift;
    my $post    = shift;

    $in =~ s/^\s+//;
    $in =~ s/\s+$//;

    if ($in =~ /^[a-zA-Z_]\w*/) {
        return $in if !$top;
        $in = '$' . $in;
    }

    my $out = $top ? eval "package $package; no strict 'vars'; $in" : $in;

    my @kv = _expand($out);

    if (@kv > 1) {
        my $joiner = ' ';
        my $indent = '';
        if ($pre =~ /^\s*$/ && $post =~ /^\s*$/) {
            $joiner = "\n";
            $indent = $pre;
        }

        my $first = 0;
        $out = join $joiner, map {
            my ($k, $v) = @$_;
            $k =~ s/_/-/g;
            $v = _process($package, $v, 0, $pre, $post);
            ($first++ ? $indent : '') . "$k: $v;";
        }
        sort {$a->[0] cmp $b->[0]} @kv;
    }
    elsif ($kv[0] =~ /^\d+$/) {
        $out .= 'px';
    }

    return $out;
}

# try to expand an array/hash ref, recursively, into a list of pairs
# if a value is a reference, then the key is dropped and the value is expanded
# in place
sub _expand {
    my $in = shift;
    return $in if !ref($in);

    my @kv;

    if (ref($in) eq 'HASH') {
        while (my ($k, $v) = each %$in) {
            if (ref($v)) {
                push @kv, _expand($v);
            }
            else {
                push @kv, [$k => $v];
            }
        }
    }
    elsif (ref($in) eq 'ARRAY') {
        if (ref($in->[0]) eq 'ARRAY') {
            for (@$in) {
                my ($k, $v) = @$_;
                if (ref($v)) {
                    push @kv, _expand($v);
                }
                else {
                    push @kv, [$k => $v];
                }
            }
        }
        else {
            my $i;
            for ($i = 0; $i < @$in; $i += 2) {
                my ($k, $v) = ($in->[$i], $in->[$i+1]);
                if (ref($v)) {
                    push @kv, _expand($v);
                }
                else {
                    push @kv, [$k => $v];
                }
            }
        }
    }

    return @kv;
}

1;

__END__