Sidef/Types/Hash/Hash.pm untested

filter: Statementstmt 0.0% 0 / 413 Branchbran 0.0% 0 / 74 Conditioncond 0.0% 0 / 55 MC/DCmcdc 0.0% 0 / 32 Subroutinesub 0.0% 0 / 65 Podpod 0.0% 0 / 52 totaltotal 0.0% 0 / 691 CC 38 SCAR 20.8
CC
38
Cov
0%
_dump
42.0
symmetric_difference
20.0
count
12.0
CRAP 8.0
1 package Sidef::Types::Hash::Hash;
2  
3 use utf8;
4 use 5.016;
5  
6 use parent qw(Sidef::Object::Object);
7  
8 use overload
9 q{bool} => sub { scalar(CORE::keys(%{$_[0]})) },
10 q{0+} => sub { scalar(CORE::keys(%{$_[0]})) },
11 q{""} => \&_dump;
12  
13 use Sidef::Types::Bool::Bool;
14 use Sidef::Types::Number::Number;
15 use Sidef::Types::Block::Block;
16  
17 sub new {
18 (@_ == 2 && ref($_[1]) eq 'HASH')
19 ? bless($_[1])
20 : do {
21 shift(@_);
22 bless {@_};
23 };
24 }
25  
26 *call = \&new;
27  
28 sub get_value {
29 my %addr;
30  
31 my $sub = sub {
32 my ($obj) = @_;
33  
34 my $refaddr = Scalar::Util::refaddr($obj);
35  
36 CORE::exists($addr{$refaddr})
37 && return $addr{$refaddr};
38  
39 my %hash;
40 $addr{$refaddr} = \%hash;
41  
42 foreach my $k (CORE::keys(%$obj)) {
43 my $v = $obj->{$k};
44 $hash{$k} = (
45 index(ref($v), 'Sidef::') == 0
46 ? $v->get_value
47 : $v
48 );
49 }
50  
51 $addr{$refaddr};
52 };
53  
54 no warnings 'redefine';
55 local *Sidef::Types::Hash::Hash::get_value = $sub;
56 $sub->($_[0]);
57 }
58  
59 sub is_empty {
60 my ($self) = @_;
61 CORE::keys(%$self)
62 ? Sidef::Types::Bool::Bool::FALSE
63 : Sidef::Types::Bool::Bool::TRUE;
64 }
65  
66 sub clear {
67 my ($self) = @_;
68 %$self = ();
69 $self;
70 }
71  
72 sub items {
73 my ($self, @keys) = @_;
74 Sidef::Types::Array::Array->new([map { CORE::exists($self->{$_}) ? $self->{$_} : undef } @keys]);
75 }
76  
77 sub item {
78 my ($self, $key) = @_;
79 CORE::exists($self->{$key}) ? $self->{$key} : undef;
80 }
81  
82 sub fetch {
83 my ($self, $key, $default) = @_;
84 CORE::exists($self->{$key}) ? $self->{$key} : $default;
85 }
86  
87 sub dig {
88 my ($self, $key, @keys) = @_;
89  
90 my $value = $self->fetch($key) // return undef;
91  
92 foreach my $key (@keys) {
93 $value = $value->fetch($key) // return undef;
94 }
95  
96 $value;
97 }
98  
99 sub slice {
100 my ($self, @keys) = @_;
101 bless {map { ($_ => $self->{$_}) } @keys}, ref($self);
102 }
103  
104 sub length {
105 my ($self) = @_;
106 Sidef::Types::Number::Number::_set_int(scalar CORE::keys(%$self));
107 }
108  
109 *len = \&length;
110 *size = \&length;
111  
112 sub eq {
113 my ($self, $hash) = @_;
114  
115 my %addr; # support for cyclic references
116  
117 my $sub = sub {
118 my ($h1, $h2) = @_;
119  
120 scalar(CORE::keys(%$h1)) == scalar(CORE::keys(%$h2))
121 or return (Sidef::Types::Bool::Bool::FALSE);
122  
123 my $refaddr1 = Scalar::Util::refaddr($h1);
124 my $refaddr2 = Scalar::Util::refaddr($h2);
125  
126 if ($refaddr1 == $refaddr2) {
127 return Sidef::Types::Bool::Bool::TRUE;
128 }
129  
130 CORE::exists($addr{$refaddr1})
131 and return $addr{$refaddr1};
132  
133 CORE::exists($addr{$refaddr2})
134 and return $addr{$refaddr2};
135  
136 $addr{$refaddr1} = Sidef::Types::Bool::Bool::FALSE;
137 $addr{$refaddr2} = Sidef::Types::Bool::Bool::FALSE;
138  
139 foreach my $key (CORE::keys(%$h1)) {
140  
141 CORE::exists($h2->{$key})
142 or return (Sidef::Types::Bool::Bool::FALSE);
143  
144 $h1->{$key} eq $h2->{$key}
145 or return (Sidef::Types::Bool::Bool::FALSE);
146 }
147  
148 (Sidef::Types::Bool::Bool::TRUE);
149 };
150  
151 no strict 'refs';
152 no warnings 'redefine';
153  
154 local *{__PACKAGE__ . '::' . 'eq'} = $sub;
155 local *{__PACKAGE__ . '::' . '=='} = $sub;
156 $sub->($self, $hash);
157 }
158  
159 sub ne {
160 my ($self, $obj) = @_;
161 $self->eq($obj)->not;
162 }
163  
164 sub same_keys {
165 my ($self, $obj) = @_;
166  
167 if (ref($self) ne ref($obj)
168 or scalar(CORE::keys(%$self)) != scalar(CORE::keys(%{$obj}))) {
169 return (Sidef::Types::Bool::Bool::FALSE);
170 }
171  
172 foreach my $key (CORE::keys(%$self)) {
173 CORE::exists($obj->{$key})
174 or return (Sidef::Types::Bool::Bool::FALSE);
175 }
176  
177 (Sidef::Types::Bool::Bool::TRUE);
178 }
179  
180 sub append {
181 my ($self, %pairs) = @_;
182  
183 foreach my $key (CORE::keys(%pairs)) {
184 $self->{$key} = $pairs{$key};
185 }
186  
187 $self;
188 }
189  
190 sub delete {
191 my ($self, @keys) = @_;
192 CORE::delete(@{$self}{@keys});
193 }
194  
195 *remove = \&delete;
196  
197 sub set_keys {
198 my ($self, @keys) = @_;
199 if (@keys) {
200 undef @{$self}{@keys};
201 }
202 $self;
203 }
204  
205 sub map_val {
206 my ($self, $block) = @_;
207  
208 my %hash;
209 foreach my $key (CORE::keys(%$self)) {
210 $hash{$key} = $block->run(Sidef::Types::String::String->new($key), $self->{$key});
211 }
212  
213 bless \%hash, ref($self);
214 }
215  
216 *map_v = \&map_val;
217  
218 sub map {
219 my ($self, $block) = @_;
220  
221 $block //= Sidef::Types::Block::Block::LIST_IDENTITY;
222  
223 my %hash;
224 foreach my $key (CORE::keys(%$self)) {
225 my @pairs = $block->run(Sidef::Types::String::String->new($key), $self->{$key});
226  
227 while (@pairs) {
228 my ($k, $v) = splice(@pairs, 0, 2);
229 $hash{$k} = $v;
230 }
231 }
232  
233 bless \%hash, ref($self);
234 }
235  
236 *map_kv = \↦
237  
238 sub collect {
239 my ($self, $block) = @_;
240  
241 $block //= Sidef::Types::Block::Block::ARRAY_IDENTITY;
242  
243 my @array;
244 foreach my $key (CORE::keys(%$self)) {
245 CORE::push(@array, $block->run(Sidef::Types::String::String->new($key), $self->{$key}));
246 }
247  
248 Sidef::Types::Array::Array->new(\@array);
249 }
250  
251 *collect_kv = \&collect;
252  
253 sub grep {
254 my ($self, $block) = @_;
255  
256 my %hash;
257 foreach my $key (CORE::keys(%$self)) {
258 my $value = $self->{$key};
259 if ($block->run(Sidef::Types::String::String->new($key), $value)) {
260 $hash{$key} = $value;
261 }
262 }
263  
264 bless \%hash, ref($self);
265 }
266  
267 *grep_kv = \&grep;
268 *select = \&grep;
269  
270 sub grep_val {
271 my ($self, $block) = @_;
272  
273 $block //= Sidef::Types::Block::Block::IDENTITY;
274  
275 my %hash;
276 foreach my $key (CORE::keys(%$self)) {
277 my $value = $self->{$key};
278 if ($block->run($value)) {
279 $hash{$key} = $value;
280 }
281 }
282  
283 bless \%hash, ref($self);
284 }
285  
286 *grep_v = \&grep_val;
287  
288 sub linear_selection {
289 my ($self, $keys) = @_;
290  
291 my @keys = $keys->to_list;
292  
293 my %retval;
294 @{retval}{@keys} = @{$self}{@keys};
295 bless \%retval;
296 }
297  
298 *lsel = \&linear_selection;
299 *linsel = \&linear_selection;
300  
301 sub count_by {
302 my ($self, $block) = @_;
303  
304 my $count = 0;
305 foreach my $key (CORE::keys(%$self)) {
306 if ($block->run(Sidef::Types::String::String->new($key), $self->{$key})) {
307 ++$count;
308 }
309 }
310  
311 Sidef::Types::Number::Number::_set_int($count);
312 }
313  
314 sub count {
315 my ($self, $obj) = @_;
316  
317 if (ref($obj) eq 'Sidef::Types::Block::Block') {
318 goto &count_by;
319 }
320  
321 if (CORE::exists($self->{$obj})) {
322 return Sidef::Types::Number::Number::ONE;
323 }
324  
325 Sidef::Types::Number::Number::ZERO;
326 }
327  
328 sub delete_if {
329 my ($self, $block) = @_;
330  
331 foreach my $key (CORE::keys(%$self)) {
332 if ($block->run(Sidef::Types::String::String->new($key), $self->{$key})) {
333 CORE::delete($self->{$key});
334 }
335 }
336  
337 $self;
338 }
339  
340 sub concat {
341 my ($self, $obj) = @_;
342  
343 #<<<
344 UNIVERSAL::isa($obj, __PACKAGE__) ? bless({%$self, %$obj}, ref($self))
345 : UNIVERSAL::isa($obj, 'Sidef::Types::Array::Array') ? bless({%$self, @$obj}, ref($self))
346 : bless({%$self, $obj}, ref($self));
347 #>>>
348 }
349  
350 *merge = \&concat;
351  
352 sub merge_values {
353 my ($self, $obj) = @_;
354  
355 foreach my $key (CORE::keys(%$self)) {
356 if (CORE::exists($obj->{$key})) {
357 $self->{$key} = $obj->{$key};
358 }
359 }
360  
361 $self;
362 }
363  
364 sub keys {
365 my ($self) = @_;
366 Sidef::Types::Array::Array->new([map { Sidef::Types::String::String->new($_) } CORE::keys(%$self)]);
367 }
368  
369 sub values {
370 my ($self) = @_;
371 Sidef::Types::Array::Array->new([CORE::values(%$self)]);
372 }
373  
374 sub each_value {
375 my ($self, $block) = @_;
376  
377 foreach my $value (CORE::values(%$self)) {
378 $block->run($value);
379 }
380  
381 $self;
382 }
383  
384 *each_v = \&each_value;
385  
386 sub each_key {
387 my ($self, $block) = @_;
388  
389 foreach my $key (CORE::keys(%$self)) {
390 $block->run(Sidef::Types::String::String->new($key));
391 }
392  
393 $self;
394 }
395  
396 *each_k = \&each_key;
397  
398 sub each {
399 my ($self, $obj) = @_;
400  
401 if (defined($obj)) {
402  
403 foreach my $key (CORE::keys(%$self)) {
404 $obj->run(Sidef::Types::String::String->new($key), $self->{$key});
405 }
406  
407 return $obj;
408 }
409  
410 my ($key, $value) = each(%$self);
411 $key // return undef;
412 (Sidef::Types::String::String->new($key), $value);
413 }
414  
415 *each_kv = \&each;
416 *each_pair = \&each;
417  
418 sub sort_by {
419 my ($self, $block) = @_;
420  
421 my @array;
422 foreach my $key (CORE::keys(%$self)) {
423 my $str = Sidef::Types::String::String->new($key);
424 push @array, [$key, $str, $block->run($str, $self->{$key})];
425 }
426  
427 Sidef::Types::Array::Array->new([map { Sidef::Types::Array::Pair->new($_->[1], $self->{$_->[0]}) } (CORE::sort { $a->[2] cmp $b->[2] } @array)]);
428 }
429  
430 sub sort {
431 my ($self, $block) = @_;
432  
433 if (defined $block) {
434 return
435 Sidef::Types::Array::Array->new(
436 [
437 map { Sidef::Types::Array::Pair->new($_->[1], $self->{$_->[0]}) } (
438 CORE::sort { scalar $block->run($a->[1], $b->[1]) }
439 map { [$_, Sidef::Types::String::String->new($_)] } CORE::keys(%$self)
440 )
441 ]
442 );
443 }
444  
445 Sidef::Types::Array::Array->new(map { Sidef::Types::Array::Pair->new(Sidef::Types::String::String->new($_), $self->{$_}) } CORE::sort(CORE::keys(%$self)));
446 }
447  
448 sub _min_max {
449 my ($self, $block, $value) = @_;
450  
451 my @pairs = map { [$_, $block->run(Sidef::Types::String::String->new($_), $self->{$_})] } CORE::keys(%$self);
452  
453 my $item = $pairs[0];
454 foreach my $i (1 .. $#pairs) {
455 $item = $pairs[$i] if (($pairs[$i][1] cmp $item->[1]) eq $value);
456 }
457  
458 Sidef::Types::Array::Pair->new(Sidef::Types::String::String->new($item->[0]), $self->{$item->[0]});
459 }
460  
461 sub max_by {
462 my ($self, $block) = @_;
463 $self->_min_max($block, Sidef::Types::Number::Number::ONE);
464 }
465  
466 sub min_by {
467 my ($self, $block) = @_;
468 $self->_min_max($block, Sidef::Types::Number::Number::MONE);
469 }
470  
471 sub to_a {
472 my ($self) = @_;
473  
474 ref($self) || return Sidef::Types::Array::Array->new($self);
475  
476 Sidef::Types::Array::Array->new([map { Sidef::Types::Array::Pair->new(Sidef::Types::String::String->new($_), $self->{$_}) } CORE::keys(%$self)]);
477 }
478  
479 *to_array = \&to_a;
480 *kv = \&to_a;
481 *pairs = \&to_a;
482  
483 sub as_tree {
484 my ($self, $root) = @_;
485  
486 my %addr;
487  
488 my $sub = sub {
489 my ($obj, $root) = @_;
490  
491 my $refaddr = Scalar::Util::refaddr($obj);
492  
493 CORE::exists($addr{$refaddr})
494 && return $addr{$refaddr};
495  
496 my @body;
497 $addr{$refaddr} = Sidef::Types::Array::Pair->new($root, \@body);
498  
499 foreach my $k (sort { (CORE::length($a) <=> CORE::length($b)) || ($a cmp $b) } CORE::keys(%$obj)) {
500 my $v = $obj->{$k};
501 if (ref($v) eq __PACKAGE__ or UNIVERSAL::isa($v, __PACKAGE__)) {
502 push @body, $v->as_tree(Sidef::Types::String::String->new($k));
503 }
504 else {
505 push @body, Sidef::Types::Array::Pair->new(Sidef::Types::String::String->new($k), Sidef::Types::Array::Array->new);
506 }
507 }
508  
509 bless \@body, 'Sidef::Types::Array::Array';
510 $addr{$refaddr};
511 };
512  
513 no warnings 'redefine';
514 local *Sidef::Types::Hash::Hash::as_tree = $sub;
515 $sub->($_[0], $root);
516 }
517  
518 sub get_pairs {
519 my ($self, @keys) = @_;
520 Sidef::Types::Array::Array->new([map { Sidef::Types::Array::Pair->new($_, $self->{$_}) } @keys]);
521 }
522  
523 sub get_pair {
524 my ($self, $key) = @_;
525 Sidef::Types::Array::Pair->new($key, $self->{$key});
526 }
527  
528 sub exists {
529 my ($self, $key) = @_;
530 CORE::exists($self->{$key})
531 ? (Sidef::Types::Bool::Bool::TRUE)
532 : (Sidef::Types::Bool::Bool::FALSE);
533 }
534  
535 *has = \&exists;
536 *haskey = \&exists;
537 *has_key = \&exists;
538 *contain = \&exists;
539 *contains = \&exists;
540 *include = \&exists;
541 *includes = \&exists;
542  
543 sub reverse {
544 my ($self) = @_;
545 my %hash;
546 @hash{CORE::values(%$self)} = (map { Sidef::Types::String::String->new($_) } CORE::keys(%$self));
547 bless \%hash, ref($self);
548 }
549  
550 *flip = \&reverse;
551 *invert = \&reverse;
552  
553 sub intersection {
554 my ($A, $B) = @_;
555  
556 if (ref($A) ne ref($B)) {
557 return $A->linear_selection($A->to_set->intersection($B));
558 }
559  
560 my %C;
561  
562 foreach my $key (CORE::keys(%$A)) {
563 if (CORE::exists($B->{$key})) {
564 $C{$key} = $A->{$key};
565 }
566 }
567  
568 bless \%C, ref($A);
569 }
570  
571 *and = \&intersection;
572  
573 sub difference {
574 my ($A, $B) = @_;
575  
576 if (ref($A) ne ref($B)) {
577 return $A->linear_selection($A->to_set->difference($B));
578 }
579  
580 my %C;
581  
582 foreach my $key (CORE::keys(%$A)) {
583 if (!CORE::exists($B->{$key})) {
584 $C{$key} = $A->{$key};
585 }
586 }
587  
588 bless \%C, ref($A);
589 }
590  
591 *sub = \&difference;
592 *diff = \&difference;
593  
594 sub union {
595 my ($A, $B) = @_;
596  
597 if (ref($A) ne ref($B)) {
598 return $A->linear_selection($A->to_set->union($B));
599 }
600  
601 my %C = %$A;
602 foreach my $key (CORE::keys(%$B)) {
603 if (!CORE::exists($C{$key})) {
604 $C{$key} = $B->{$key};
605 }
606 }
607  
608 bless \%C, ref($A);
609 }
610  
611 *or = \&union;
612  
613 sub symmetric_difference {
614 my ($A, $B) = @_;
615  
616 if (ref($A) ne ref($B)) {
617 return $A->linear_selection($A->to_set->symmetric_difference($B));
618 }
619  
620 my %C;
621  
622 foreach my $key (CORE::keys(%$A)) {
623 if (!CORE::exists($B->{$key})) {
624 $C{$key} = $A->{$key};
625 }
626 }
627  
628 foreach my $key (CORE::keys(%$B)) {
629 if (!CORE::exists($A->{$key})) {
630 $C{$key} = $B->{$key};
631 }
632 }
633  
634 bless \%C, ref($A);
635 }
636  
637 *xor = \&symmetric_difference;
638 *symdiff = \&symmetric_difference;
639  
640 sub to_list {
641 my ($self) = @_;
642 map { (Sidef::Types::String::String->new($_), $self->{$_}) } CORE::keys(%$self);
643 }
644  
645 sub _dump {
646 my %addr; # keeps track of dumped objects
647  
648 my $sub = sub {
649 my ($obj) = @_;
650  
651 my $refaddr = Scalar::Util::refaddr($obj);
652  
653 CORE::exists($addr{$refaddr})
654 and return $addr{$refaddr};
655  
656 $Sidef::SPACES += $Sidef::SPACES_INCR;
657  
658 # Sort the keys case insensitively
659 my @keys = CORE::sort { (lc($a) cmp lc($b)) || ($a cmp $b) } CORE::keys(%$obj);
660  
661 $addr{$refaddr} = "Hash(#`($refaddr)...)";
662  
663 my ($s, $val);
664  
665 my $str = (
666 "Hash(" . (
667 @keys
668 ? (
669 (@keys > 1 ? "\n" : '') . join(
670 ",\n",
671 map {
672 (@keys > 1 ? (' ' x $Sidef::SPACES) : '')
673 . "${Sidef::Types::String::String->new($_)->dump} => "
674 . (
675 (ref($val = $obj->{$_}) && ($s = UNIVERSAL::can($val, 'dump')))
676 ? $s->($val)
677 : ($val // 'nil')
678 )
679 } @keys
680 )
681 . (@keys > 1 ? ("\n" . (' ' x ($Sidef::SPACES - $Sidef::SPACES_INCR))) : '')
682 )
683 : ""
684 )
685 . ")"
686 );
687  
688 $Sidef::SPACES -= $Sidef::SPACES_INCR;
689 $str;
690 };
691  
692 no warnings 'redefine';
693 local *Sidef::Types::Hash::Hash::dump = $sub;
694 $sub->($_[0]);
695 }
696  
697 sub dump {
698 Sidef::Types::String::String->new($_[0]->_dump);
699 }
700  
701 *to_s = \&dump;
702 *to_str = \&dump;
703  
704 sub to_set {
705 $_[0]->keys->to_set;
706 }
707  
708 sub to_bag {
709 $_[0]->keys->to_bag;
710 }
711  
712 {
713 no strict 'refs';
714  
715 *{__PACKAGE__ . '::' . '+'} = \&concat;
716 *{__PACKAGE__ . '::' . '=='} = \&eq;
717 *{__PACKAGE__ . '::' . '!='} = \&ne;
718 *{__PACKAGE__ . '::' . '≠'} = \&ne;
719 *{__PACKAGE__ . '::' . '...'} = \&to_list;
720  
721 *{__PACKAGE__ . '::' . '&'} = \&intersection;
722 *{__PACKAGE__ . '::' . '-'} = \&difference;
723 *{__PACKAGE__ . '::' . '|'} = \&union;
724 *{__PACKAGE__ . '::' . '^'} = \&symmetric_difference;
725 }
726  
727 1