File Coverage

blib/lib/YAML/Tidy/Node.pm
Criterion Covered Total %
statement 230 235 97.8
branch 43 46 93.4
condition 25 26 96.1
subroutine 40 40 100.0
pod 0 1 0.0
total 338 348 97.1


line stmt bran cond sub pod time code
1             # ABSTRACT: yamltidy parse tree element
2 6     6   35 use strict;
  6         8  
  6         147  
3 6     6   28 use warnings;
  6         10  
  6         122  
4 6     6   57 use v5.20;
  6         35  
5 6     6   34 use experimental qw/ signatures /;
  6         9  
  6         26  
6              
7             package YAML::Tidy::Node;
8              
9             our $VERSION = '0.006'; # VERSION
10 6     6   1748 use overload '""' => \&_stringify;
  6         768  
  6         41  
11              
12 31844     31844 0 38901 sub new($class, %args) {
  31844         34651  
  31844         68778  
  31844         32549  
13 31844         90619 my $self = {
14             %args,
15             };
16 31844         85343 return bless $self, $class;
17             }
18              
19 44872     44872   48819 sub _stringify($self, @args) {
  44872         46576  
  44872         61846  
  44872         43857  
20 44872   50     74303 my $type = $self->{type} // '';
21 44872         65763 my $str = "($type)";
22 44872 50       60272 if ($self->is_collection) {
23 44872         55841 my $open = $self->open;
24 44872         59580 my $close = $self->close;
25             $str .= sprintf " - ",
26             $open->{start}->{line}, $open->{start}->{column},
27             $open->{end}->{line}, $open->{end}->{column},
28             $close->{start}->{line}, $close->{start}->{column},
29             $close->{end}->{line}, $close->{end}->{column},
30 44872         183944 }
31             else {
32 0         0 my $val = substr($self->{value}, 0, 20);
33 0         0 local $Data::Dumper::Useqq = 1;
34 0         0 $val = Data::Dumper->Dump([$val], ['val']);
35 0         0 chomp $val;
36             $str .= sprintf " - | %s",
37             $self->start->{line}, $self->start->{column},
38 0         0 $self->end->{line}, $self->end->{column}, $val
39             }
40 44872         101828 return $str;
41             }
42              
43             package YAML::Tidy::Node::Collection;
44 6 50   6   2099 use constant DEBUG => $ENV{YAML_TIDY_DEBUG} ? 1 : 0;
  6         10  
  6         371  
45              
46 6     6   31 use base 'YAML::Tidy::Node';
  6         8  
  6         6828  
47              
48 67861     67861   103767 sub is_collection { 1 }
49              
50 35911     35911   38031 sub indent($self) {
  35911         37581  
  35911         35014  
51 35911         44131 my $firstevent = $self->open;
52 35911 100       64668 if ($firstevent->{name} eq 'document_start_event') {
53 7460         14682 return 0;
54             }
55 28451         34847 my $startcol = $firstevent->{end}->{column};
56 28451         42717 return $startcol;
57             }
58              
59 127551     127551   124040 sub open($self) { $self->{start} }
  127551         122450  
  127551         120945  
  127551         186748  
60 71631     71631   72227 sub close($self) { $self->{end} }
  71631         72273  
  71631         67504  
  71631         103430  
61              
62 12589     12589   14216 sub end($self) {
  12589         14038  
  12589         13225  
63 12589         18606 return $self->close->{end};
64             }
65              
66 588     588   856 sub realendline($self) {
  588         773  
  588         719  
67 588         950 $self->close->{end}->{line} - 1;
68             }
69              
70 17590     17590   18969 sub start($self) {
  17590         18474  
  17590         17968  
71 17590         24804 return $self->open->{start};
72             }
73              
74 10917     10917   12137 sub line($self) {
  10917         12478  
  10917         11098  
75              
76 10917         17216 my $contentstart = $self->contentstart;
77 10917         18108 return $contentstart->{line};
78             }
79              
80 10917     10917   11965 sub contentstart($self) {
  10917         12728  
  10917         11317  
81 10917         15618 my $firstevent = $self->open;
82 10917         16206 return $firstevent->{end};
83             }
84              
85 786     786   1144 sub fix_node_indent($self, $fix) {
  786         962  
  786         1029  
  786         1010  
86 786         1379 for my $e ($self->open, $self->close) {
87 1572         2838 for my $pos (@$e{qw/ start end /}) {
88 3144         4653 $pos->{column} += $fix;
89             }
90             }
91 786         1140 for my $c (@{ $self->{children} }) {
  786         1747  
92 1931         3222 $c->fix_node_indent($fix);
93             }
94             }
95              
96 5264     5264   5478 sub _move_columns($self, $line, $offset, $fix) {
  5264         5561  
  5264         5639  
  5264         5574  
  5264         5249  
  5264         5105  
97             # warn __PACKAGE__.':'.__LINE__.": MOVE $self $line $offset $fix\n";
98 5264 100       6612 return if $self->end->{line} < $line;
99 4645 100       6371 return if $self->start->{line} > $line;
100 3866         5208 for my $e ($self->open, $self->close) {
101 7732         10884 for my $pos (@$e{qw/ start end /}) {
102 15464 100 100     29332 if ($pos->{line} == $line and $pos->{column} >= $offset) {
103 106         187 $pos->{column} += $fix;
104             }
105             }
106             }
107 3866         4201 for my $c (@{ $self->{children} }) {
  3866         5919  
108 11337         16478 $c->_move_columns($line, $offset, $fix);
109             }
110             }
111              
112              
113 1626     1626   1988 sub _fix_flow_indent($self, %args) {
  1626         1930  
  1626         2815  
  1626         1758  
114 1626         2203 my $line = $args{line};
115 1626         2012 my $diff = $args{diff};
116 1626         2229 my $start = $self->open;
117 1626         2590 my $end = $self->close;
118 1626         3241 for my $pos ($start->{start}, $start->{end}, $end->{start}, $end->{end}) {
119 6504 100       10390 if ($pos->{line} == $line) {
120 2620         3568 $pos->{column} += $diff;
121             }
122             }
123 1626         1847 for my $c (@{ $self->{children} }) {
  1626         2699  
124 3684         7123 $c->_fix_flow_indent(%args);
125             }
126             }
127              
128 3957     3957   4162 sub fix_lines($self, $startline, $diff) {
  3957         4535  
  3957         4641  
  3957         4242  
  3957         3904  
129 3957         4973 my $start = $self->open;
130 3957         4174 DEBUG and warn __PACKAGE__.':'.__LINE__.": ======== fix_lines $startline $diff ($self)\n";
131 3957         5111 my $end = $self->close;
132 3957         6202 for my $pos ($start->{start}, $start->{end}) {
133 7914 100       13130 if ($pos->{line} >= $startline) {
134 3336         4154 $pos->{line} += $diff;
135             }
136             }
137 3957         5642 for my $pos ($end->{start}, $end->{end}) {
138 7914 100 100     21522 if ($pos->{column} == 0 and $pos->{line} == $startline) {
    100          
139             }
140             elsif ($pos->{line} >= $startline) {
141 3846         4978 $pos->{line} += $diff;
142             }
143             }
144 3957         4222 for my $c (@{ $self->{children} }) {
  3957         6194  
145 7476         11620 $c->fix_lines($startline, $diff);
146             }
147             }
148              
149             package YAML::Tidy::Node::Scalar;
150 6 50   6   43 use constant DEBUG => $ENV{YAML_TIDY_DEBUG} ? 1 : 0;
  6         11  
  6         347  
151 6         418 use YAML::PP::Common qw/
152             YAML_PLAIN_SCALAR_STYLE YAML_SINGLE_QUOTED_SCALAR_STYLE
153             YAML_DOUBLE_QUOTED_SCALAR_STYLE YAML_LITERAL_SCALAR_STYLE
154             YAML_FOLDED_SCALAR_STYLE
155             YAML_FLOW_SEQUENCE_STYLE YAML_FLOW_MAPPING_STYLE
156 6     6   2611 /;
  6         7837  
157              
158 6     6   42 use base 'YAML::Tidy::Node';
  6         10  
  6         5918  
159              
160 27012     27012   55645 sub is_collection { 0 }
161              
162 18269     18269   20186 sub indent($self) {
  18269         19445  
  18269         18623  
163 18269         24848 return $self->open->{column};
164             }
165              
166 38663     38663   40140 sub start($self) {
  38663         39744  
  38663         37498  
167 38663         49668 return $self->open;
168             }
169              
170 122806     122806   119534 sub open($self) { $self->{start} }
  122806         119910  
  122806         116314  
  122806         200321  
171 96208     96208   94795 sub close($self) { $self->{end} }
  96208         94315  
  96208         91400  
  96208         156055  
172              
173 17609     17609   19310 sub end($self) {
  17609         19023  
  17609         17435  
174 17609         22945 return $self->close;
175             }
176              
177 13176     13176   15101 sub realendline($self) {
  13176         14401  
  13176         13452  
178 13176         18373 my $end = $self->close;
179 13176 100 100     41332 if ($self->{style} == YAML_LITERAL_SCALAR_STYLE
180             or $self->{style} == YAML_FOLDED_SCALAR_STYLE) {
181 2494 100       5868 if ($end->{column} == 0) {
182 2414         5510 return $end->{line} - 1;
183             }
184             }
185 10762         17553 $end->{line};
186             }
187              
188 20732     20732   22411 sub line($self) {
  20732         22359  
  20732         20829  
189 20732         30788 my $contentstart = $self->contentstart;
190 20732         35353 return $contentstart->{line};
191             }
192              
193 20732     20732   21871 sub contentstart($self) {
  20732         23008  
  20732         21442  
194 20732         28532 return $self->start;
195             }
196              
197 20459     20459   22529 sub multiline($self) {
  20459         21268  
  20459         20505  
198 20459 100       26747 if ($self->open->{line} < $self->close->{line}) {
199 2826         9363 return 1;
200             }
201 17633         42664 return 0;
202             }
203              
204 23549     23549   26763 sub empty_scalar($self) {
  23549         25395  
  23549         22805  
205 23549         32199 my ($start, $end) = ($self->open, $self->close);
206 23549 100 100     70937 if ($start->{line} == $end->{line} and $start->{column} == $end->{column}) {
207 551         1849 return 1;
208             }
209 22998         53867 return 0;
210             }
211              
212 1733     1733   1867 sub fix_node_indent($self, $fix) {
  1733         1917  
  1733         1946  
  1733         1942  
213 1733         2808 for my $pos ($self->open, $self->close) {
214 3466         5590 $pos->{column} += $fix;
215             }
216             }
217              
218 7150     7150   7378 sub _move_columns($self, $line, $offset, $fix) {
  7150         7025  
  7150         7249  
  7150         6961  
  7150         6951  
  7150         6620  
219             # warn __PACKAGE__.':'.__LINE__.": MOVE $self $line $offset $fix\n";
220 7150 100       8736 return if $self->end->{line} < $line;
221 4348 100       5998 return if $self->start->{line} > $line;
222 1819         2905 for my $pos ($self->open, $self->close) {
223 3638 100 100     10631 if ($pos->{line} == $line and $pos->{column} >= $offset) {
224 836         1427 $pos->{column} += $fix;
225             }
226             }
227             # warn __PACKAGE__.':'.__LINE__.": MOVE $self $line $offset $fix\n";
228             }
229              
230 3251     3251   3642 sub _fix_flow_indent($self, %args) {
  3251         3659  
  3251         4233  
  3251         3385  
231 3251         3906 my $line = $args{line};
232 3251         3690 my $diff = $args{diff};
233 3251         4562 for my $pos ($self->open, $self->close) {
234 6502 100       12886 if ($pos->{line} == $line) {
235 2442         5219 $pos->{column} += $diff;
236             }
237             }
238             }
239              
240 4500     4500   4568 sub fix_lines($self, $startline, $diff) {
  4500         4594  
  4500         4392  
  4500         4392  
  4500         4763  
241 4500         4596 DEBUG and warn __PACKAGE__.':'.__LINE__.": ======== fix_lines $startline $diff ($self)\n";
242 4500         6065 for my $pos ($self->open) {
243 4500 100 100     6687 if ($self->empty_scalar and $pos->{column} == 0 and $pos->{line} == $startline) {
    100 100        
244             }
245             elsif ($pos->{line} >= $startline) {
246 2178         3083 $pos->{line} += $diff;
247             }
248             }
249 4500         6016 for my $pos ($self->close) {
250 4500 100 100     12846 if ($pos->{column} == 0 and $pos->{line} == $startline) {
    100          
251             }
252             elsif ($pos->{line} >= $startline) {
253 2178         4228 $pos->{line} += $diff;
254             }
255             }
256             }
257              
258             1;