blib/lib/Venus/Regexp.pm

filter: Statementstmt 100% 30 / 30 Branchbran n/a Conditioncond 62.5% 5 / 8 MC/DCmcdc 25.0% 1 / 4 Subroutinesub 100% 12 / 12 Podpod 75.0% 3 / 4 totaltotal 87.9% 51 / 58 CC 5 SCAR 6.5
CC
5
Cov
92%
replace
4.1
search
2.0
BEGIN
1.0
CRAP 1.9
« blib/lib/Venus/Role/Unacceptable.pm ↑ Summary blib/lib/Venus/Role/Accessible.pm »
1 package Venus::Regexp;
2  
3 13 ▶use 5.018;
Subroutine BEGIN: called CC=1 SCAR=0.0
4  
5 13 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 13 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 # IMPORTS
9  
10 13 ▶use Venus::Class 'base';
Subroutine BEGIN: called CC=1 SCAR=0.0
11  
12 # INHERITS
13  
14 13 base 'Venus::Kind::Value';
15  
16 # OVERLOADS
17  
18 13 ▶use overload (
Subroutine BEGIN: called CC=1 SCAR=0.0
19 1 ▶ 'eq' => sub{"$_[0]" eq "$_[1]"},
Subroutine __ANON__: called CC=1 SCAR=0.0
20 1 ▶ 'ne' => sub{"$_[0]" ne "$_[1]"},
Subroutine __ANON__: called CC=1 SCAR=0.0
21 1 ▶ 'qr' => sub{$_[0]->value},
Subroutine __ANON__: called CC=1 SCAR=0.0
22 13 fallback => 1,
23 13 );
24  
25 # METHODS
26  
27 212 ▶sub comparer {
Subroutine comparer: called CC=1 SCAR=0.0
Pod undocumented
28 212 my ($self) = @_;
29  
30 212 return 'stringified';
31 }
32  
33 183 ▶sub default {
Subroutine default: called CC=1 SCAR=0.0
Pod documented
34 183 return qr//;
35 }
36  
37 3 ▶sub replace {
Subroutine replace: called CC=4 SCAR=14.2
Pod documented
38 3 my ($self, $string, $substr, $flags) = @_;
39  
40 3 require Venus::Replace;
41  
42 3 ▶ my $replace = Venus::Replace->new(
Condition66%4/6
$string // ""
l!l
30
$substr // ""
l!l
30
$flags // ""
l!l
12
MC/DC0%0/1
$string // ""
$string
MC/DC0%0/1
$substr // ""
$substr
MC/DC100%1/1
$flags // ""
$flags
Truth table50%1/2
A
A= $string
Aresult
11
00
Truth table50%1/2
A
A= $substr
Aresult
11
00
Truth table100%2/2
A
A= $flags
Aresult
11
00
43 regexp => $self->get,
44 string => $string // '',
45 substr => $substr // '',
46 flags => $flags // '',
47 );
48  
49 3 return $replace->do('evaluate');
50 }
51  
52 2 ▶sub search {
Subroutine search: called CC=2 SCAR=7.0
Pod documented
53 2 my ($self, $string) = @_;
54  
55 2 require Venus::Search;
56  
57 2 ▶ my $search = Venus::Search->new(
Condition50%1/2
$string // ""
l!l
20
MC/DC0%0/1
$string // ""
$string
Truth table50%1/2
A
A= $string
Aresult
11
00
58 regexp => $self->get,
59 string => $string // '',
60 );
61  
62 2 return $search->do('evaluate');
63 }
64  
65 13 1;
66  
67  
68  
69 =head1 NAME
70  
71 Venus::Regexp - Regexp Class
72  
73 =cut
74  
75 =head1 ABSTRACT
76  
77 Regexp Class for Perl 5
78  
79 =cut
80  
81 =head1 SYNOPSIS
82  
83 package main;
84  
85 use Venus::Regexp;
86  
87 my $regexp = Venus::Regexp->new(
88 qr/(?<greet>\w+) (?<username>\w+)/u,
89 );
90  
91 # $regexp->search;
92  
93 =cut
94  
95 =head1 DESCRIPTION
96  
97 This package provides methods for manipulating regexp data.
98  
99 =cut
100  
101 =head1 INHERITS
102  
103 This package inherits behaviors from:
104  
105 L<Venus::Kind::Value>
106  
107 =cut
108  
109 =head1 METHODS
110  
111 This package provides the following methods:
112  
113 =cut
114  
115 =head2 cast
116  
117 cast(string $kind) (object | undef)
118  
119 The cast method converts L<"value"|Venus::Kind::Value> objects between
120 different I<"value"> object types, based on the name of the type provided. This
121 method will return C<undef> if the invocant is not a L<Venus::Kind::Value>.
122  
123 I<Since C<0.08>>
124  
125 =over 4
126  
127 =item cast example 1
128  
129 package main;
130  
131 use Venus::Regexp;
132  
133 my $regexp = Venus::Regexp->new;
134  
135 my $cast = $regexp->cast('array');
136  
137 # bless({ value => [qr/(?^u:)/] }, "Venus::Array")
138  
139 =back
140  
141 =over 4
142  
143 =item cast example 2
144  
145 package main;
146  
147 use Venus::Regexp;
148  
149 my $regexp = Venus::Regexp->new;
150  
151 my $cast = $regexp->cast('boolean');
152  
153 # bless({ value => 1 }, "Venus::Boolean")
154  
155 =back
156  
157 =over 4
158  
159 =item cast example 3
160  
161 package main;
162  
163 use Venus::Regexp;
164  
165 my $regexp = Venus::Regexp->new;
166  
167 my $cast = $regexp->cast('code');
168  
169 # bless({ value => sub { ... } }, "Venus::Code")
170  
171 =back
172  
173 =over 4
174  
175 =item cast example 4
176  
177 package main;
178  
179 use Venus::Regexp;
180  
181 my $regexp = Venus::Regexp->new;
182  
183 my $cast = $regexp->cast('float');
184  
185 # bless({ value => "1.0" }, "Venus::Float")
186  
187 =back
188  
189 =over 4
190  
191 =item cast example 5
192  
193 package main;
194  
195 use Venus::Regexp;
196  
197 my $regexp = Venus::Regexp->new;
198  
199 my $cast = $regexp->cast('hash');
200  
201 # bless({ value => { "0" => qr/(?^u:)/ } }, "Venus::Hash")
202  
203 =back
204  
205 =over 4
206  
207 =item cast example 6
208  
209 package main;
210  
211 use Venus::Regexp;
212  
213 my $regexp = Venus::Regexp->new;
214  
215 my $cast = $regexp->cast('number');
216  
217 # bless({ value => 5 }, "Venus::Number")
218  
219 =back
220  
221 =over 4
222  
223 =item cast example 7
224  
225 package main;
226  
227 use Venus::Regexp;
228  
229 my $regexp = Venus::Regexp->new;
230  
231 my $cast = $regexp->cast('regexp');
232  
233 # bless({ value => qr/(?^u:)/ }, "Venus::Regexp")
234  
235 =back
236  
237 =over 4
238  
239 =item cast example 8
240  
241 package main;
242  
243 use Venus::Regexp;
244  
245 my $regexp = Venus::Regexp->new;
246  
247 my $cast = $regexp->cast('scalar');
248  
249 # bless({ value => \qr/(?^u:)/ }, "Venus::Scalar")
250  
251 =back
252  
253 =over 4
254  
255 =item cast example 9
256  
257 package main;
258  
259 use Venus::Regexp;
260  
261 my $regexp = Venus::Regexp->new;
262  
263 my $cast = $regexp->cast('string');
264  
265 # bless({ value => "qr//u" }, "Venus::String")
266  
267 =back
268  
269 =over 4
270  
271 =item cast example 10
272  
273 package main;
274  
275 use Venus::Regexp;
276  
277 my $regexp = Venus::Regexp->new;
278  
279 my $cast = $regexp->cast('undef');
280  
281 # bless({ value => undef }, "Venus::Undef")
282  
283 =back
284  
285 =cut
286  
287 =head2 default
288  
289 default() (regexp)
290  
291 The default method returns the default value, i.e. C<qr//>.
292  
293 I<Since C<0.01>>
294  
295 =over 4
296  
297 =item default example 1
298  
299 # given: synopsis;
300  
301 my $default = $regexp->default;
302  
303 # qr/(?^u:)/
304  
305 =back
306  
307 =cut
308  
309 =head2 eq
310  
311 eq(any $arg) (boolean)
312  
313 The eq method performs an I<"equals"> operation using the argument provided.
314  
315 I<Since C<0.08>>
316  
317 =over 4
318  
319 =item eq example 1
320  
321 package main;
322  
323 use Venus::Array;
324 use Venus::Regexp;
325  
326 my $lvalue = Venus::Regexp->new;
327 my $rvalue = Venus::Array->new;
328  
329 my $result = $lvalue->eq($rvalue);
330  
331 # 0
332  
333 =back
334  
335 =over 4
336  
337 =item eq example 2
338  
339 package main;
340  
341 use Venus::Code;
342 use Venus::Regexp;
343  
344 my $lvalue = Venus::Regexp->new;
345 my $rvalue = Venus::Code->new;
346  
347 my $result = $lvalue->eq($rvalue);
348  
349 # 0
350  
351 =back
352  
353 =over 4
354  
355 =item eq example 3
356  
357 package main;
358  
359 use Venus::Float;
360 use Venus::Regexp;
361  
362 my $lvalue = Venus::Regexp->new;
363 my $rvalue = Venus::Float->new;
364  
365 my $result = $lvalue->eq($rvalue);
366  
367 # 0
368  
369 =back
370  
371 =over 4
372  
373 =item eq example 4
374  
375 package main;
376  
377 use Venus::Hash;
378 use Venus::Regexp;
379  
380 my $lvalue = Venus::Regexp->new;
381 my $rvalue = Venus::Hash->new;
382  
383 my $result = $lvalue->eq($rvalue);
384  
385 # 0
386  
387 =back
388  
389 =over 4
390  
391 =item eq example 5
392  
393 package main;
394  
395 use Venus::Number;
396 use Venus::Regexp;
397  
398 my $lvalue = Venus::Regexp->new;
399 my $rvalue = Venus::Number->new;
400  
401 my $result = $lvalue->eq($rvalue);
402  
403 # 0
404  
405 =back
406  
407 =over 4
408  
409 =item eq example 6
410  
411 package main;
412  
413 use Venus::Regexp;
414  
415 my $lvalue = Venus::Regexp->new;
416 my $rvalue = Venus::Regexp->new;
417  
418 my $result = $lvalue->eq($rvalue);
419  
420 # 1
421  
422 =back
423  
424 =over 4
425  
426 =item eq example 7
427  
428 package main;
429  
430 use Venus::Regexp;
431 use Venus::Scalar;
432  
433 my $lvalue = Venus::Regexp->new;
434 my $rvalue = Venus::Scalar->new;
435  
436 my $result = $lvalue->eq($rvalue);
437  
438 # 0
439  
440 =back
441  
442 =over 4
443  
444 =item eq example 8
445  
446 package main;
447  
448 use Venus::Regexp;
449 use Venus::String;
450  
451 my $lvalue = Venus::Regexp->new;
452 my $rvalue = Venus::String->new;
453  
454 my $result = $lvalue->eq($rvalue);
455  
456 # 0
457  
458 =back
459  
460 =over 4
461  
462 =item eq example 9
463  
464 package main;
465  
466 use Venus::Regexp;
467 use Venus::Undef;
468  
469 my $lvalue = Venus::Regexp->new;
470 my $rvalue = Venus::Undef->new;
471  
472 my $result = $lvalue->eq($rvalue);
473  
474 # 0
475  
476 =back
477  
478 =cut
479  
480 =head2 ge
481  
482 ge(any $arg) (boolean)
483  
484 The ge method performs a I<"greater-than-or-equal-to"> operation using the
485 argument provided.
486  
487 I<Since C<0.08>>
488  
489 =over 4
490  
491 =item ge example 1
492  
493 package main;
494  
495 use Venus::Array;
496 use Venus::Regexp;
497  
498 my $lvalue = Venus::Regexp->new;
499 my $rvalue = Venus::Array->new;
500  
501 my $result = $lvalue->ge($rvalue);
502  
503 # 1
504  
505 =back
506  
507 =over 4
508  
509 =item ge example 2
510  
511 package main;
512  
513 use Venus::Code;
514 use Venus::Regexp;
515  
516 my $lvalue = Venus::Regexp->new;
517 my $rvalue = Venus::Code->new;
518  
519 my $result = $lvalue->ge($rvalue);
520  
521 # 0
522  
523 =back
524  
525 =over 4
526  
527 =item ge example 3
528  
529 package main;
530  
531 use Venus::Float;
532 use Venus::Regexp;
533  
534 my $lvalue = Venus::Regexp->new;
535 my $rvalue = Venus::Float->new;
536  
537 my $result = $lvalue->ge($rvalue);
538  
539 # 1
540  
541 =back
542  
543 =over 4
544  
545 =item ge example 4
546  
547 package main;
548  
549 use Venus::Hash;
550 use Venus::Regexp;
551  
552 my $lvalue = Venus::Regexp->new;
553 my $rvalue = Venus::Hash->new;
554  
555 my $result = $lvalue->ge($rvalue);
556  
557 # 0
558  
559 =back
560  
561 =over 4
562  
563 =item ge example 5
564  
565 package main;
566  
567 use Venus::Number;
568 use Venus::Regexp;
569  
570 my $lvalue = Venus::Regexp->new;
571 my $rvalue = Venus::Number->new;
572  
573 my $result = $lvalue->ge($rvalue);
574  
575 # 1
576  
577 =back
578  
579 =over 4
580  
581 =item ge example 6
582  
583 package main;
584  
585 use Venus::Regexp;
586  
587 my $lvalue = Venus::Regexp->new;
588 my $rvalue = Venus::Regexp->new;
589  
590 my $result = $lvalue->ge($rvalue);
591  
592 # 1
593  
594 =back
595  
596 =over 4
597  
598 =item ge example 7
599  
600 package main;
601  
602 use Venus::Regexp;
603 use Venus::Scalar;
604  
605 my $lvalue = Venus::Regexp->new;
606 my $rvalue = Venus::Scalar->new;
607  
608 my $result = $lvalue->ge($rvalue);
609  
610 # 1
611  
612 =back
613  
614 =over 4
615  
616 =item ge example 8
617  
618 package main;
619  
620 use Venus::Regexp;
621 use Venus::String;
622  
623 my $lvalue = Venus::Regexp->new;
624 my $rvalue = Venus::String->new;
625  
626 my $result = $lvalue->ge($rvalue);
627  
628 # 1
629  
630 =back
631  
632 =over 4
633  
634 =item ge example 9
635  
636 package main;
637  
638 use Venus::Regexp;
639 use Venus::Undef;
640  
641 my $lvalue = Venus::Regexp->new;
642 my $rvalue = Venus::Undef->new;
643  
644 my $result = $lvalue->ge($rvalue);
645  
646 # 1
647  
648 =back
649  
650 =cut
651  
652 =head2 gele
653  
654 gele(any $arg1, any $arg2) (boolean)
655  
656 The gele method performs a I<"greater-than-or-equal-to"> operation on the 1st
657 argument, and I<"lesser-than-or-equal-to"> operation on the 2nd argument.
658  
659 I<Since C<0.08>>
660  
661 =over 4
662  
663 =item gele example 1
664  
665 package main;
666  
667 use Venus::Array;
668 use Venus::Regexp;
669  
670 my $lvalue = Venus::Regexp->new;
671 my $rvalue = Venus::Array->new;
672  
673 my $result = $lvalue->gele($rvalue);
674  
675 # 0
676  
677 =back
678  
679 =over 4
680  
681 =item gele example 2
682  
683 package main;
684  
685 use Venus::Code;
686 use Venus::Regexp;
687  
688 my $lvalue = Venus::Regexp->new;
689 my $rvalue = Venus::Code->new;
690  
691 my $result = $lvalue->gele($rvalue);
692  
693 # 0
694  
695 =back
696  
697 =over 4
698  
699 =item gele example 3
700  
701 package main;
702  
703 use Venus::Float;
704 use Venus::Regexp;
705  
706 my $lvalue = Venus::Regexp->new;
707 my $rvalue = Venus::Float->new;
708  
709 my $result = $lvalue->gele($rvalue);
710  
711 # 0
712  
713 =back
714  
715 =over 4
716  
717 =item gele example 4
718  
719 package main;
720  
721 use Venus::Hash;
722 use Venus::Regexp;
723  
724 my $lvalue = Venus::Regexp->new;
725 my $rvalue = Venus::Hash->new;
726  
727 my $result = $lvalue->gele($rvalue);
728  
729 # 0
730  
731 =back
732  
733 =over 4
734  
735 =item gele example 5
736  
737 package main;
738  
739 use Venus::Number;
740 use Venus::Regexp;
741  
742 my $lvalue = Venus::Regexp->new;
743 my $rvalue = Venus::Number->new;
744  
745 my $result = $lvalue->gele($rvalue);
746  
747 # 0
748  
749 =back
750  
751 =over 4
752  
753 =item gele example 6
754  
755 package main;
756  
757 use Venus::Regexp;
758  
759 my $lvalue = Venus::Regexp->new;
760 my $rvalue = Venus::Regexp->new;
761  
762 my $result = $lvalue->gele($rvalue);
763  
764 # 0
765  
766 =back
767  
768 =over 4
769  
770 =item gele example 7
771  
772 package main;
773  
774 use Venus::Regexp;
775 use Venus::Scalar;
776  
777 my $lvalue = Venus::Regexp->new;
778 my $rvalue = Venus::Scalar->new;
779  
780 my $result = $lvalue->gele($rvalue);
781  
782 # 0
783  
784 =back
785  
786 =over 4
787  
788 =item gele example 8
789  
790 package main;
791  
792 use Venus::Regexp;
793 use Venus::String;
794  
795 my $lvalue = Venus::Regexp->new;
796 my $rvalue = Venus::String->new;
797  
798 my $result = $lvalue->gele($rvalue);
799  
800 # 0
801  
802 =back
803  
804 =over 4
805  
806 =item gele example 9
807  
808 package main;
809  
810 use Venus::Regexp;
811 use Venus::Undef;
812  
813 my $lvalue = Venus::Regexp->new;
814 my $rvalue = Venus::Undef->new;
815  
816 my $result = $lvalue->gele($rvalue);
817  
818 # 0
819  
820 =back
821  
822 =cut
823  
824 =head2 gt
825  
826 gt(any $arg) (boolean)
827  
828 The gt method performs a I<"greater-than"> operation using the argument provided.
829  
830 I<Since C<0.08>>
831  
832 =over 4
833  
834 =item gt example 1
835  
836 package main;
837  
838 use Venus::Array;
839 use Venus::Regexp;
840  
841 my $lvalue = Venus::Regexp->new;
842 my $rvalue = Venus::Array->new;
843  
844 my $result = $lvalue->gt($rvalue);
845  
846 # 1
847  
848 =back
849  
850 =over 4
851  
852 =item gt example 2
853  
854 package main;
855  
856 use Venus::Code;
857 use Venus::Regexp;
858  
859 my $lvalue = Venus::Regexp->new;
860 my $rvalue = Venus::Code->new;
861  
862 my $result = $lvalue->gt($rvalue);
863  
864 # 0
865  
866 =back
867  
868 =over 4
869  
870 =item gt example 3
871  
872 package main;
873  
874 use Venus::Float;
875 use Venus::Regexp;
876  
877 my $lvalue = Venus::Regexp->new;
878 my $rvalue = Venus::Float->new;
879  
880 my $result = $lvalue->gt($rvalue);
881  
882 # 1
883  
884 =back
885  
886 =over 4
887  
888 =item gt example 4
889  
890 package main;
891  
892 use Venus::Hash;
893 use Venus::Regexp;
894  
895 my $lvalue = Venus::Regexp->new;
896 my $rvalue = Venus::Hash->new;
897  
898 my $result = $lvalue->gt($rvalue);
899  
900 # 0
901  
902 =back
903  
904 =over 4
905  
906 =item gt example 5
907  
908 package main;
909  
910 use Venus::Number;
911 use Venus::Regexp;
912  
913 my $lvalue = Venus::Regexp->new;
914 my $rvalue = Venus::Number->new;
915  
916 my $result = $lvalue->gt($rvalue);
917  
918 # 1
919  
920 =back
921  
922 =over 4
923  
924 =item gt example 6
925  
926 package main;
927  
928 use Venus::Regexp;
929  
930 my $lvalue = Venus::Regexp->new;
931 my $rvalue = Venus::Regexp->new;
932  
933 my $result = $lvalue->gt($rvalue);
934  
935 # 0
936  
937 =back
938  
939 =over 4
940  
941 =item gt example 7
942  
943 package main;
944  
945 use Venus::Regexp;
946 use Venus::Scalar;
947  
948 my $lvalue = Venus::Regexp->new;
949 my $rvalue = Venus::Scalar->new;
950  
951 my $result = $lvalue->gt($rvalue);
952  
953 # 1
954  
955 =back
956  
957 =over 4
958  
959 =item gt example 8
960  
961 package main;
962  
963 use Venus::Regexp;
964 use Venus::String;
965  
966 my $lvalue = Venus::Regexp->new;
967 my $rvalue = Venus::String->new;
968  
969 my $result = $lvalue->gt($rvalue);
970  
971 # 1
972  
973 =back
974  
975 =over 4
976  
977 =item gt example 9
978  
979 package main;
980  
981 use Venus::Regexp;
982 use Venus::Undef;
983  
984 my $lvalue = Venus::Regexp->new;
985 my $rvalue = Venus::Undef->new;
986  
987 my $result = $lvalue->gt($rvalue);
988  
989 # 1
990  
991 =back
992  
993 =cut
994  
995 =head2 gtlt
996  
997 gtlt(any $arg1, any $arg2) (boolean)
998  
999 The gtlt method performs a I<"greater-than"> operation on the 1st argument, and
1000 I<"lesser-than"> operation on the 2nd argument.
1001  
1002 I<Since C<0.08>>
1003  
1004 =over 4
1005  
1006 =item gtlt example 1
1007  
1008 package main;
1009  
1010 use Venus::Array;
1011 use Venus::Regexp;
1012  
1013 my $lvalue = Venus::Regexp->new;
1014 my $rvalue = Venus::Array->new;
1015  
1016 my $result = $lvalue->gtlt($rvalue);
1017  
1018 # 0
1019  
1020 =back
1021  
1022 =over 4
1023  
1024 =item gtlt example 2
1025  
1026 package main;
1027  
1028 use Venus::Code;
1029 use Venus::Regexp;
1030  
1031 my $lvalue = Venus::Regexp->new;
1032 my $rvalue = Venus::Code->new;
1033  
1034 my $result = $lvalue->gtlt($rvalue);
1035  
1036 # 0
1037  
1038 =back
1039  
1040 =over 4
1041  
1042 =item gtlt example 3
1043  
1044 package main;
1045  
1046 use Venus::Float;
1047 use Venus::Regexp;
1048  
1049 my $lvalue = Venus::Regexp->new;
1050 my $rvalue = Venus::Float->new;
1051  
1052 my $result = $lvalue->gtlt($rvalue);
1053  
1054 # 0
1055  
1056 =back
1057  
1058 =over 4
1059  
1060 =item gtlt example 4
1061  
1062 package main;
1063  
1064 use Venus::Hash;
1065 use Venus::Regexp;
1066  
1067 my $lvalue = Venus::Regexp->new;
1068 my $rvalue = Venus::Hash->new;
1069  
1070 my $result = $lvalue->gtlt($rvalue);
1071  
1072 # 0
1073  
1074 =back
1075  
1076 =over 4
1077  
1078 =item gtlt example 5
1079  
1080 package main;
1081  
1082 use Venus::Number;
1083 use Venus::Regexp;
1084  
1085 my $lvalue = Venus::Regexp->new;
1086 my $rvalue = Venus::Number->new;
1087  
1088 my $result = $lvalue->gtlt($rvalue);
1089  
1090 # 0
1091  
1092 =back
1093  
1094 =over 4
1095  
1096 =item gtlt example 6
1097  
1098 package main;
1099  
1100 use Venus::Regexp;
1101  
1102 my $lvalue = Venus::Regexp->new;
1103 my $rvalue = Venus::Regexp->new;
1104  
1105 my $result = $lvalue->gtlt($rvalue);
1106  
1107 # 0
1108  
1109 =back
1110  
1111 =over 4
1112  
1113 =item gtlt example 7
1114  
1115 package main;
1116  
1117 use Venus::Regexp;
1118 use Venus::Scalar;
1119  
1120 my $lvalue = Venus::Regexp->new;
1121 my $rvalue = Venus::Scalar->new;
1122  
1123 my $result = $lvalue->gtlt($rvalue);
1124  
1125 # 0
1126  
1127 =back
1128  
1129 =over 4
1130  
1131 =item gtlt example 8
1132  
1133 package main;
1134  
1135 use Venus::Regexp;
1136 use Venus::String;
1137  
1138 my $lvalue = Venus::Regexp->new;
1139 my $rvalue = Venus::String->new;
1140  
1141 my $result = $lvalue->gtlt($rvalue);
1142  
1143 # 0
1144  
1145 =back
1146  
1147 =over 4
1148  
1149 =item gtlt example 9
1150  
1151 package main;
1152  
1153 use Venus::Regexp;
1154 use Venus::Undef;
1155  
1156 my $lvalue = Venus::Regexp->new;
1157 my $rvalue = Venus::Undef->new;
1158  
1159 my $result = $lvalue->gtlt($rvalue);
1160  
1161 # 0
1162  
1163 =back
1164  
1165 =cut
1166  
1167 =head2 le
1168  
1169 le(any $arg) (boolean)
1170  
1171 The le method performs a I<"lesser-than-or-equal-to"> operation using the
1172 argument provided.
1173  
1174 I<Since C<0.08>>
1175  
1176 =over 4
1177  
1178 =item le example 1
1179  
1180 package main;
1181  
1182 use Venus::Array;
1183 use Venus::Regexp;
1184  
1185 my $lvalue = Venus::Regexp->new;
1186 my $rvalue = Venus::Array->new;
1187  
1188 my $result = $lvalue->le($rvalue);
1189  
1190 # 0
1191  
1192 =back
1193  
1194 =over 4
1195  
1196 =item le example 2
1197  
1198 package main;
1199  
1200 use Venus::Code;
1201 use Venus::Regexp;
1202  
1203 my $lvalue = Venus::Regexp->new;
1204 my $rvalue = Venus::Code->new;
1205  
1206 my $result = $lvalue->le($rvalue);
1207  
1208 # 1
1209  
1210 =back
1211  
1212 =over 4
1213  
1214 =item le example 3
1215  
1216 package main;
1217  
1218 use Venus::Float;
1219 use Venus::Regexp;
1220  
1221 my $lvalue = Venus::Regexp->new;
1222 my $rvalue = Venus::Float->new;
1223  
1224 my $result = $lvalue->le($rvalue);
1225  
1226 # 0
1227  
1228 =back
1229  
1230 =over 4
1231  
1232 =item le example 4
1233  
1234 package main;
1235  
1236 use Venus::Hash;
1237 use Venus::Regexp;
1238  
1239 my $lvalue = Venus::Regexp->new;
1240 my $rvalue = Venus::Hash->new;
1241  
1242 my $result = $lvalue->le($rvalue);
1243  
1244 # 1
1245  
1246 =back
1247  
1248 =over 4
1249  
1250 =item le example 5
1251  
1252 package main;
1253  
1254 use Venus::Number;
1255 use Venus::Regexp;
1256  
1257 my $lvalue = Venus::Regexp->new;
1258 my $rvalue = Venus::Number->new;
1259  
1260 my $result = $lvalue->le($rvalue);
1261  
1262 # 0
1263  
1264 =back
1265  
1266 =over 4
1267  
1268 =item le example 6
1269  
1270 package main;
1271  
1272 use Venus::Regexp;
1273  
1274 my $lvalue = Venus::Regexp->new;
1275 my $rvalue = Venus::Regexp->new;
1276  
1277 my $result = $lvalue->le($rvalue);
1278  
1279 # 1
1280  
1281 =back
1282  
1283 =over 4
1284  
1285 =item le example 7
1286  
1287 package main;
1288  
1289 use Venus::Regexp;
1290 use Venus::Scalar;
1291  
1292 my $lvalue = Venus::Regexp->new;
1293 my $rvalue = Venus::Scalar->new;
1294  
1295 my $result = $lvalue->le($rvalue);
1296  
1297 # 0
1298  
1299 =back
1300  
1301 =over 4
1302  
1303 =item le example 8
1304  
1305 package main;
1306  
1307 use Venus::Regexp;
1308 use Venus::String;
1309  
1310 my $lvalue = Venus::Regexp->new;
1311 my $rvalue = Venus::String->new;
1312  
1313 my $result = $lvalue->le($rvalue);
1314  
1315 # 0
1316  
1317 =back
1318  
1319 =over 4
1320  
1321 =item le example 9
1322  
1323 package main;
1324  
1325 use Venus::Regexp;
1326 use Venus::Undef;
1327  
1328 my $lvalue = Venus::Regexp->new;
1329 my $rvalue = Venus::Undef->new;
1330  
1331 my $result = $lvalue->le($rvalue);
1332  
1333 # 0
1334  
1335 =back
1336  
1337 =cut
1338  
1339 =head2 lt
1340  
1341 lt(any $arg) (boolean)
1342  
1343 The lt method performs a I<"lesser-than"> operation using the argument provided.
1344  
1345 I<Since C<0.08>>
1346  
1347 =over 4
1348  
1349 =item lt example 1
1350  
1351 package main;
1352  
1353 use Venus::Array;
1354 use Venus::Regexp;
1355  
1356 my $lvalue = Venus::Regexp->new;
1357 my $rvalue = Venus::Array->new;
1358  
1359 my $result = $lvalue->lt($rvalue);
1360  
1361 # 0
1362  
1363 =back
1364  
1365 =over 4
1366  
1367 =item lt example 2
1368  
1369 package main;
1370  
1371 use Venus::Code;
1372 use Venus::Regexp;
1373  
1374 my $lvalue = Venus::Regexp->new;
1375 my $rvalue = Venus::Code->new;
1376  
1377 my $result = $lvalue->lt($rvalue);
1378  
1379 # 1
1380  
1381 =back
1382  
1383 =over 4
1384  
1385 =item lt example 3
1386  
1387 package main;
1388  
1389 use Venus::Float;
1390 use Venus::Regexp;
1391  
1392 my $lvalue = Venus::Regexp->new;
1393 my $rvalue = Venus::Float->new;
1394  
1395 my $result = $lvalue->lt($rvalue);
1396  
1397 # 0
1398  
1399 =back
1400  
1401 =over 4
1402  
1403 =item lt example 4
1404  
1405 package main;
1406  
1407 use Venus::Hash;
1408 use Venus::Regexp;
1409  
1410 my $lvalue = Venus::Regexp->new;
1411 my $rvalue = Venus::Hash->new;
1412  
1413 my $result = $lvalue->lt($rvalue);
1414  
1415 # 1
1416  
1417 =back
1418  
1419 =over 4
1420  
1421 =item lt example 5
1422  
1423 package main;
1424  
1425 use Venus::Number;
1426 use Venus::Regexp;
1427  
1428 my $lvalue = Venus::Regexp->new;
1429 my $rvalue = Venus::Number->new;
1430  
1431 my $result = $lvalue->lt($rvalue);
1432  
1433 # 0
1434  
1435 =back
1436  
1437 =over 4
1438  
1439 =item lt example 6
1440  
1441 package main;
1442  
1443 use Venus::Regexp;
1444  
1445 my $lvalue = Venus::Regexp->new;
1446 my $rvalue = Venus::Regexp->new;
1447  
1448 my $result = $lvalue->lt($rvalue);
1449  
1450 # 0
1451  
1452 =back
1453  
1454 =over 4
1455  
1456 =item lt example 7
1457  
1458 package main;
1459  
1460 use Venus::Regexp;
1461 use Venus::Scalar;
1462  
1463 my $lvalue = Venus::Regexp->new;
1464 my $rvalue = Venus::Scalar->new;
1465  
1466 my $result = $lvalue->lt($rvalue);
1467  
1468 # 0
1469  
1470 =back
1471  
1472 =over 4
1473  
1474 =item lt example 8
1475  
1476 package main;
1477  
1478 use Venus::Regexp;
1479 use Venus::String;
1480  
1481 my $lvalue = Venus::Regexp->new;
1482 my $rvalue = Venus::String->new;
1483  
1484 my $result = $lvalue->lt($rvalue);
1485  
1486 # 0
1487  
1488 =back
1489  
1490 =over 4
1491  
1492 =item lt example 9
1493  
1494 package main;
1495  
1496 use Venus::Regexp;
1497 use Venus::Undef;
1498  
1499 my $lvalue = Venus::Regexp->new;
1500 my $rvalue = Venus::Undef->new;
1501  
1502 my $result = $lvalue->lt($rvalue);
1503  
1504 # 0
1505  
1506 =back
1507  
1508 =cut
1509  
1510 =head2 ne
1511  
1512 ne(any $arg) (boolean)
1513  
1514 The ne method performs a I<"not-equal-to"> operation using the argument provided.
1515  
1516 I<Since C<0.08>>
1517  
1518 =over 4
1519  
1520 =item ne example 1
1521  
1522 package main;
1523  
1524 use Venus::Array;
1525 use Venus::Regexp;
1526  
1527 my $lvalue = Venus::Regexp->new;
1528 my $rvalue = Venus::Array->new;
1529  
1530 my $result = $lvalue->ne($rvalue);
1531  
1532 # 1
1533  
1534 =back
1535  
1536 =over 4
1537  
1538 =item ne example 2
1539  
1540 package main;
1541  
1542 use Venus::Code;
1543 use Venus::Regexp;
1544  
1545 my $lvalue = Venus::Regexp->new;
1546 my $rvalue = Venus::Code->new;
1547  
1548 my $result = $lvalue->ne($rvalue);
1549  
1550 # 1
1551  
1552 =back
1553  
1554 =over 4
1555  
1556 =item ne example 3
1557  
1558 package main;
1559  
1560 use Venus::Float;
1561 use Venus::Regexp;
1562  
1563 my $lvalue = Venus::Regexp->new;
1564 my $rvalue = Venus::Float->new;
1565  
1566 my $result = $lvalue->ne($rvalue);
1567  
1568 # 1
1569  
1570 =back
1571  
1572 =over 4
1573  
1574 =item ne example 4
1575  
1576 package main;
1577  
1578 use Venus::Hash;
1579 use Venus::Regexp;
1580  
1581 my $lvalue = Venus::Regexp->new;
1582 my $rvalue = Venus::Hash->new;
1583  
1584 my $result = $lvalue->ne($rvalue);
1585  
1586 # 1
1587  
1588 =back
1589  
1590 =over 4
1591  
1592 =item ne example 5
1593  
1594 package main;
1595  
1596 use Venus::Number;
1597 use Venus::Regexp;
1598  
1599 my $lvalue = Venus::Regexp->new;
1600 my $rvalue = Venus::Number->new;
1601  
1602 my $result = $lvalue->ne($rvalue);
1603  
1604 # 1
1605  
1606 =back
1607  
1608 =over 4
1609  
1610 =item ne example 6
1611  
1612 package main;
1613  
1614 use Venus::Regexp;
1615  
1616 my $lvalue = Venus::Regexp->new;
1617 my $rvalue = Venus::Regexp->new;
1618  
1619 my $result = $lvalue->ne($rvalue);
1620  
1621 # 0
1622  
1623 =back
1624  
1625 =over 4
1626  
1627 =item ne example 7
1628  
1629 package main;
1630  
1631 use Venus::Regexp;
1632 use Venus::Scalar;
1633  
1634 my $lvalue = Venus::Regexp->new;
1635 my $rvalue = Venus::Scalar->new;
1636  
1637 my $result = $lvalue->ne($rvalue);
1638  
1639 # 1
1640  
1641 =back
1642  
1643 =over 4
1644  
1645 =item ne example 8
1646  
1647 package main;
1648  
1649 use Venus::Regexp;
1650 use Venus::String;
1651  
1652 my $lvalue = Venus::Regexp->new;
1653 my $rvalue = Venus::String->new;
1654  
1655 my $result = $lvalue->ne($rvalue);
1656  
1657 # 1
1658  
1659 =back
1660  
1661 =over 4
1662  
1663 =item ne example 9
1664  
1665 package main;
1666  
1667 use Venus::Regexp;
1668 use Venus::Undef;
1669  
1670 my $lvalue = Venus::Regexp->new;
1671 my $rvalue = Venus::Undef->new;
1672  
1673 my $result = $lvalue->ne($rvalue);
1674  
1675 # 1
1676  
1677 =back
1678  
1679 =cut
1680  
1681 =head2 new
1682  
1683 new(any @args) (Venus::Regexp)
1684  
1685 The new method constructs an instance of the package.
1686  
1687 I<Since C<4.15>>
1688  
1689 =over 4
1690  
1691 =item new example 1
1692  
1693 package main;
1694  
1695 use Venus::Regexp;
1696  
1697 my $new = Venus::Regexp->new;
1698  
1699 # bless(..., "Venus::Regexp")
1700  
1701 =back
1702  
1703 =over 4
1704  
1705 =item new example 2
1706  
1707 package main;
1708  
1709 use Venus::Regexp;
1710  
1711 my $new = Venus::Regexp->new(qr/(?<greet>\w+) (?<username>\w+)/u);
1712  
1713 # bless(..., "Venus::Regexp")
1714  
1715 =back
1716  
1717 =over 4
1718  
1719 =item new example 3
1720  
1721 package main;
1722  
1723 use Venus::Regexp;
1724  
1725 my $new = Venus::Regexp->new(value => qr/(?<greet>\w+) (?<username>\w+)/u);
1726  
1727 # bless(..., "Venus::Regexp")
1728  
1729 =back
1730  
1731 =cut
1732  
1733 =head2 numified
1734  
1735 numified() (number)
1736  
1737 The numified method returns the numerical representation of the object. For
1738 regexp objects the method returns the length (or character count) of the
1739 stringified object.
1740  
1741 I<Since C<0.08>>
1742  
1743 =over 4
1744  
1745 =item numified example 1
1746  
1747 # given: synopsis;
1748  
1749 my $numified = $regexp->numified;
1750  
1751 # 36
1752  
1753 =back
1754  
1755 =over 4
1756  
1757 =item numified example 2
1758  
1759 package main;
1760  
1761 use Venus::Regexp;
1762  
1763 my $regexp = Venus::Regexp->new(
1764 qr/.*/u,
1765 );
1766  
1767 my $numified = $regexp->numified;
1768  
1769 # 7
1770  
1771 =back
1772  
1773 =cut
1774  
1775 =head2 replace
1776  
1777 replace(string $string, string $substr, string $flags) (Venus::Replace)
1778  
1779 The replace method performs a regular expression substitution on the given
1780 string. The first argument is the string to match against. The second argument
1781 is the replacement string. The optional third argument might be a string
1782 representing flags to append to the s///x operator, such as 'g' or 'e'. This
1783 method will always return a L<Venus::Replace> object which can be used to
1784 introspect the result of the operation.
1785  
1786 I<Since C<0.01>>
1787  
1788 =over 4
1789  
1790 =item replace example 1
1791  
1792 package main;
1793  
1794 use Venus::Regexp;
1795  
1796 my $regexp = Venus::Regexp->new(
1797 qr/(?<username>\w+)$/,
1798 );
1799  
1800 my $replace = $regexp->replace('Hey, unknown', 'awncorp');
1801  
1802 # bless({ ... }, 'Venus::Replace')
1803  
1804 =back
1805  
1806 =cut
1807  
1808 =head2 search
1809  
1810 search(string $string) (Venus::Search)
1811  
1812 The search method performs a regular expression match against the given string,
1813 this method will always return a L<Venus::Search> object which can be used to
1814 introspect the result of the operation.
1815  
1816 I<Since C<0.01>>
1817  
1818 =over 4
1819  
1820 =item search example 1
1821  
1822 package main;
1823  
1824 use Venus::Regexp;
1825  
1826 my $regexp = Venus::Regexp->new(
1827 qr/(?<greet>\w+), (?<username>\w+)/,
1828 );
1829  
1830 my $search = $regexp->search('hey, awncorp');
1831  
1832 # bless({ ... }, 'Venus::Search')
1833  
1834 =back
1835  
1836 =cut
1837  
1838 =head2 stringified
1839  
1840 stringified() (string)
1841  
1842 The stringified method returns the object, stringified (i.e. a dump of the
1843 object's value).
1844  
1845 I<Since C<0.08>>
1846  
1847 =over 4
1848  
1849 =item stringified example 1
1850  
1851 # given: synopsis;
1852  
1853 my $stringified = $regexp->stringified;
1854  
1855 # qr/(?<greet>\w+) (?<username>\w+)/u
1856  
1857  
1858  
1859  
1860 =back
1861  
1862 =over 4
1863  
1864 =item stringified example 2
1865  
1866 package main;
1867  
1868 use Venus::Regexp;
1869  
1870 my $regexp = Venus::Regexp->new(
1871 qr/.*/,
1872 );
1873  
1874 my $stringified = $regexp->stringified;
1875  
1876 # qr/.*/u
1877  
1878 =back
1879  
1880 =cut
1881  
1882 =head2 tv
1883  
1884 tv(any $arg) (boolean)
1885  
1886 The tv method performs a I<"type-and-value-equal-to"> operation using argument
1887 provided.
1888  
1889 I<Since C<0.08>>
1890  
1891 =over 4
1892  
1893 =item tv example 1
1894  
1895 package main;
1896  
1897 use Venus::Array;
1898 use Venus::Regexp;
1899  
1900 my $lvalue = Venus::Regexp->new;
1901 my $rvalue = Venus::Array->new;
1902  
1903 my $result = $lvalue->tv($rvalue);
1904  
1905 # 0
1906  
1907 =back
1908  
1909 =over 4
1910  
1911 =item tv example 2
1912  
1913 package main;
1914  
1915 use Venus::Code;
1916 use Venus::Regexp;
1917  
1918 my $lvalue = Venus::Regexp->new;
1919 my $rvalue = Venus::Code->new;
1920  
1921 my $result = $lvalue->tv($rvalue);
1922  
1923 # 0
1924  
1925 =back
1926  
1927 =over 4
1928  
1929 =item tv example 3
1930  
1931 package main;
1932  
1933 use Venus::Float;
1934 use Venus::Regexp;
1935  
1936 my $lvalue = Venus::Regexp->new;
1937 my $rvalue = Venus::Float->new;
1938  
1939 my $result = $lvalue->tv($rvalue);
1940  
1941 # 0
1942  
1943 =back
1944  
1945 =over 4
1946  
1947 =item tv example 4
1948  
1949 package main;
1950  
1951 use Venus::Hash;
1952 use Venus::Regexp;
1953  
1954 my $lvalue = Venus::Regexp->new;
1955 my $rvalue = Venus::Hash->new;
1956  
1957 my $result = $lvalue->tv($rvalue);
1958  
1959 # 0
1960  
1961 =back
1962  
1963 =over 4
1964  
1965 =item tv example 5
1966  
1967 package main;
1968  
1969 use Venus::Number;
1970 use Venus::Regexp;
1971  
1972 my $lvalue = Venus::Regexp->new;
1973 my $rvalue = Venus::Number->new;
1974  
1975 my $result = $lvalue->tv($rvalue);
1976  
1977 # 0
1978  
1979 =back
1980  
1981 =over 4
1982  
1983 =item tv example 6
1984  
1985 package main;
1986  
1987 use Venus::Regexp;
1988  
1989 my $lvalue = Venus::Regexp->new;
1990 my $rvalue = Venus::Regexp->new;
1991  
1992 my $result = $lvalue->tv($rvalue);
1993  
1994 # 1
1995  
1996 =back
1997  
1998 =over 4
1999  
2000 =item tv example 7
2001  
2002 package main;
2003  
2004 use Venus::Regexp;
2005 use Venus::Scalar;
2006  
2007 my $lvalue = Venus::Regexp->new;
2008 my $rvalue = Venus::Scalar->new;
2009  
2010 my $result = $lvalue->tv($rvalue);
2011  
2012 # 0
2013  
2014 =back
2015  
2016 =over 4
2017  
2018 =item tv example 8
2019  
2020 package main;
2021  
2022 use Venus::Regexp;
2023 use Venus::String;
2024  
2025 my $lvalue = Venus::Regexp->new;
2026 my $rvalue = Venus::String->new;
2027  
2028 my $result = $lvalue->tv($rvalue);
2029  
2030 # 0
2031  
2032 =back
2033  
2034 =over 4
2035  
2036 =item tv example 9
2037  
2038 package main;
2039  
2040 use Venus::Regexp;
2041 use Venus::Undef;
2042  
2043 my $lvalue = Venus::Regexp->new;
2044 my $rvalue = Venus::Undef->new;
2045  
2046 my $result = $lvalue->tv($rvalue);
2047  
2048 # 0
2049  
2050 =back
2051  
2052 =cut
2053  
2054 =head1 OPERATORS
2055  
2056 This package overloads the following operators:
2057  
2058 =cut
2059  
2060 =over 4
2061  
2062 =item operation: C<(eq)>
2063  
2064 This package overloads the C<eq> operator.
2065  
2066 B<example 1>
2067  
2068 # given: synopsis;
2069  
2070 my $result = $regexp eq '(?^u:(?<greet>\\w+) (?<username>\\w+))';
2071  
2072 # 1
2073  
2074 =back
2075  
2076 =over 4
2077  
2078 =item operation: C<(ne)>
2079  
2080 This package overloads the C<ne> operator.
2081  
2082 B<example 1>
2083  
2084 # given: synopsis;
2085  
2086 my $result = $regexp ne '(?<greet>\w+) (?<username>\w+)';
2087  
2088 # 1
2089  
2090 =back
2091  
2092 =over 4
2093  
2094 =item operation: C<(qr)>
2095  
2096 This package overloads the C<qr> operator.
2097  
2098 B<example 1>
2099  
2100 # given: synopsis;
2101  
2102 my $result = 'Hello Friend' =~ $regexp;
2103  
2104 # 1
2105  
2106 =back
2107  
2108 =head1 AUTHORS
2109  
2110 Awncorp, C<awncorp@cpan.org>
2111  
2112 =cut
2113  
2114 =head1 LICENSE
2115  
2116 Copyright (C) 2022, Awncorp, C<awncorp@cpan.org>.
2117  
2118 This program is free software, you can redistribute it and/or modify it under
2119 the terms of the Apache license version 2.0.
2120  
2121 =cut
« blib/lib/Venus/Role/Unacceptable.pm ↑ Summary blib/lib/Venus/Role/Accessible.pm »