File Coverage

blib/lib/CSS/Struct/Output/Structure.pm
Criterion Covered Total %
statement 56 56 100.0
branch 5 6 83.3
condition n/a
subroutine 14 14 100.0
pod 1 1 100.0
total 76 77 98.7


line stmt bran cond sub pod time code
1             package CSS::Struct::Output::Structure;
2              
3 11     11   69986 use base qw(CSS::Struct::Output);
  11         67  
  11         4689  
4 11     11   285590 use strict;
  11         22  
  11         176  
5 11     11   45 use warnings;
  11         16  
  11         233  
6              
7 11     11   46 use Error::Pure qw(err);
  11         19  
  11         1053  
8              
9             our $VERSION = 0.03;
10              
11             sub flush {
12 19     19 1 1412 my ($self, $reset_flag) = @_;
13              
14 19         42 my $ouf = $self->{'output_handler'};
15              
16             # Text output.
17 19         23 my $ret_ar;
18 19 100       45 if ($ouf) {
19 7         14 foreach my $line_ar (@{$self->{'flush_code'}}) {
  7         20  
20 10         83 my $line = "['";
21 10         16 $line .= join "', '", @{$line_ar};
  10         29  
22 10         23 $line .= "']".$self->{'output_sep'};
23 11     11   66 no warnings;
  11         18  
  11         3866  
24 10 50       138 print {$ouf} $line
  10         57  
25             or err 'Cannot write to output handler.';
26             }
27              
28             # Structure.
29             } else {
30 12         22 $ret_ar = $self->{'flush_code'};
31             }
32              
33             # Reset.
34 19 100       269 if ($reset_flag) {
35 1         3 $self->reset;
36             }
37              
38 19         49 return $ret_ar;
39             }
40              
41             # At-rules.
42             sub _put_at_rules {
43 2     2   1138 my ($self, $at_rule, $value) = @_;
44              
45 2         5 $self->_put_structure('a', $at_rule, $value);
46              
47 2         4 return;
48             }
49              
50             # Comment.
51             sub _put_comment {
52 4     4   2244 my ($self, @comments) = @_;
53              
54 4         11 $self->_put_structure('c', @comments);
55              
56 4         8 return;
57             }
58              
59             # Definition.
60             sub _put_definition {
61 2     2   1008 my ($self, $key, $value) = @_;
62              
63 2         6 $self->_put_structure('d', $key, $value);
64              
65 2         4 return;
66             }
67              
68             # End of selector.
69             sub _put_end_of_selector {
70 2     2   1018 my $self = shift;
71              
72 2         6 $self->_put_structure('e');
73              
74 2         4 return;
75             }
76              
77             # Instruction.
78             sub _put_instruction {
79 2     2   1279 my ($self, $target, $code) = @_;
80              
81 2         8 $self->_put_structure('i', $target, $code);
82              
83 2         5 return;
84             }
85              
86             # Raw data.
87             sub _put_raw {
88 2     2   1004 my ($self, @raw_data) = @_;
89              
90 2         7 $self->_put_structure('r', @raw_data);
91              
92 2         4 return;
93             }
94              
95             # Selectors.
96             sub _put_selector {
97 8     8   1978 my ($self, $selector) = @_;
98              
99 8         15 $self->_put_structure('s', $selector);
100              
101 8         13 return;
102             }
103              
104             # Put common structure.
105             sub _put_structure {
106 22     22   55 my ($self, @struct) = @_;
107              
108 22         30 push @{$self->{'flush_code'}}, \@struct;
  22         49  
109              
110 22         36 return;
111             }
112              
113             1;
114              
115             __END__