File Coverage

blib/lib/Faker.pm
Criterion Covered Total %
statement 46 46 100.0
branch 7 10 70.0
condition 4 6 66.6
subroutine 17 17 100.0
pod 1 11 9.0
total 75 90 83.3


line stmt bran cond sub pod time code
1             package Faker;
2              
3 149     149   492008 use 5.018;
  149         621  
4              
5 149     149   873 use strict;
  149         355  
  149         3145  
6 149     149   756 use warnings;
  149         325  
  149         4495  
7              
8 149     149   875 use Venus::Class 'attr', 'with';
  149         371  
  149         1028  
9              
10             with 'Venus::Role::Buildable';
11             with 'Venus::Role::Proxyable';
12             with 'Venus::Role::Optional';
13              
14             # VERSION
15              
16             our $VERSION = '1.17';
17              
18             # AUTHORITY
19              
20             our $AUTHORITY = 'cpan:AWNCORP';
21              
22             # STATE
23              
24             state $sources = {};
25              
26             # ATTRIBUTES
27              
28             attr 'caches';
29             attr 'locales';
30              
31             # DEFAULTS
32              
33             sub coerce_caches {
34 2769     2769 0 594175 return 'Venus::Hash';
35             }
36              
37             sub default_caches {
38 981     981 0 389443 return {};
39             }
40              
41             sub coerce_locales {
42 1493     1493 0 906279 return 'Venus::Array';
43             }
44              
45             sub default_locales {
46 184     184 0 4335053 return [];
47             }
48              
49             # BUILDERS
50              
51             sub build_arg {
52 1370     1370 0 3808413 my ($self, $data) = @_;
53              
54             return {
55 1370 100       7519 locales => ref $data eq 'ARRAY' ? $data : [$data],
56             };
57             }
58              
59             sub build_proxy {
60 1173     1173 0 1008574 my ($self, $package, $method, @args) = @_;
61              
62 1173 100   4   3468 return sub { $self->caches->get($method) } if $self->caches->exists($method);
  4         2106  
63              
64 1169 50       3501745 return unless my $source = $self->sources($method)->random;
65              
66 1169     1169   196462 return sub { $source->build(faker => $self)->execute(@args) };
  1169         107442  
67             }
68              
69             # METHODS
70              
71             sub cache {
72 6     6 1 4222 my ($self, $method, @args) = @_;
73              
74 6 50       26 return if !$method;
75              
76 6         22 my $result = $self->caches->set($method, $self->$method(@args));
77              
78 6         2349 return $result;
79             }
80              
81             sub plugin {
82 2318     2318 0 5058 my ($self, @args) = @_;
83              
84 2318         4926 return $self->space->child('plugin', @args);
85             }
86              
87             sub random {
88 4343     4343 0 1985234 my ($self) = @_;
89              
90 4343         111974 require Venus::Random;
91              
92 4343         387968 state $random = Venus::Random->new;
93              
94 4343         126471 return $random;
95             }
96              
97             sub space {
98 2318     2318 0 4022 my ($self) = @_;
99              
100 2318         9178 require Venus::Space;
101              
102 2318   33     4205 state $space = Venus::Space->new(ref $self || $self);
103              
104 2318         20104 return $space;
105             }
106              
107             sub sources {
108 1169     1169 0 2755 my ($self, $method) = @_;
109              
110 1169 50       2940 return if !$method;
111              
112 1169         6280 require Venus::Array;
113              
114 1169         3342 my $plugins = Venus::Array->new([$self->plugin($method)]);
115              
116 1169         1259781 $plugins->push(map {$self->plugin($_, $method)} $self->locales->list);
  1149         3389027  
117              
118 1169   100     1481953 $plugins->value([grep {$$sources{"$_"} //= $_->tryload} $plugins->list]);
  2318         1131761  
119              
120 1169         249134 return $plugins;
121             }
122              
123             1;
124              
125              
126             =head1 NAME
127              
128             Faker - Fake Data Generator
129              
130             =cut
131              
132             =head1 ABSTRACT
133              
134             Extensible Fake Data Generator
135              
136             =cut
137              
138             =head1 VERSION
139              
140             1.17
141              
142             =cut
143              
144             =head1 SYNOPSIS
145              
146             package main;
147              
148             use Faker;
149              
150             my $faker = Faker->new('en-us');
151              
152             # my $first_name = $faker->person_name;
153              
154             # "Russel Krajcik"
155              
156             # my $last_name = $faker->person_name;
157              
158             # "Alayna Josephine Kunde"
159              
160             =cut
161              
162             =head1 DESCRIPTION
163              
164             This distribution provides a library of fake data generators and a framework
165             for extending the library via plugins.
166              
167             =encoding utf8
168              
169             =cut
170              
171             =head1 ATTRIBUTES
172              
173             This package has the following attributes:
174              
175             =cut
176              
177             =head2 caches
178              
179             caches(HashRef $data) (Object)
180              
181             The caches attribute holds the cached values returned from L.
182              
183             I>
184              
185             =over 4
186              
187             =item caches example 1
188              
189             # given: synopsis
190              
191             package main;
192              
193             my $caches = $faker->caches;
194              
195             # bless({value => {}}, 'Venus::Hash')
196              
197             =back
198              
199             =over 4
200              
201             =item caches example 2
202              
203             # given: synopsis
204              
205             package main;
206              
207             my $caches = $faker->caches({});
208              
209             # bless({value => {}}, 'Venus::Hash')
210              
211             =back
212              
213             =cut
214              
215             =head2 locales
216              
217             locales(ArrayRef $data) (Object)
218              
219             The locales attribute holds the locales used to find and generate localized
220             data.
221              
222             I>
223              
224             =over 4
225              
226             =item locales example 1
227              
228             # given: synopsis
229              
230             package main;
231              
232             my $locales = $faker->locales;
233              
234             # bless({value => []}, 'Venus::Array')
235              
236             =back
237              
238             =over 4
239              
240             =item locales example 2
241              
242             # given: synopsis
243              
244             package main;
245              
246             my $locales = $faker->locales([]);
247              
248             # bless({value => []}, 'Venus::Array')
249              
250             =back
251              
252             =cut
253              
254             =head1 INTEGRATES
255              
256             This package integrates behaviors from:
257              
258             L
259              
260             L
261              
262             L
263              
264             =cut
265              
266             =head1 METHODS
267              
268             This package provides the following methods:
269              
270             =cut
271              
272             =head2 address_city_name
273              
274             address_city_name(HashRef $data) (Str)
275              
276             The address_city_name method returns a random address city name.
277              
278             I>
279              
280             =over 4
281              
282             =item address_city_name example 1
283              
284             package main;
285              
286             use Faker;
287              
288             my $faker = Faker->new('en-us');
289              
290             # my $address_city_name = $faker->address_city_name;
291              
292             # "West Jamison"
293              
294             # $address_city_name = $faker->address_city_name;
295              
296             # "Mayertown"
297              
298             # $address_city_name = $faker->address_city_name;
299              
300             # "Juliaborough"
301              
302             =back
303              
304             =cut
305              
306             =head2 address_city_prefix
307              
308             address_city_prefix(HashRef $data) (Str)
309              
310             The address_city_prefix method returns a random address city prefix.
311              
312             I>
313              
314             =over 4
315              
316             =item address_city_prefix example 1
317              
318             package main;
319              
320             use Faker;
321              
322             my $faker = Faker->new('en-us');
323              
324             # my $address_city_prefix = $faker->address_city_prefix;
325              
326             # "West"
327              
328             # $address_city_prefix = $faker->address_city_prefix;
329              
330             # "West"
331              
332             # $address_city_prefix = $faker->address_city_prefix;
333              
334             # "Lake"
335              
336             =back
337              
338             =cut
339              
340             =head2 address_city_suffix
341              
342             address_city_suffix(HashRef $data) (Str)
343              
344             ok $address_city_suffix method returns a random address city suffix.
345              
346             I>
347              
348             =over 4
349              
350             =item address_city_suffix example 1
351              
352             package main;
353              
354             use Faker;
355              
356             my $faker = Faker->new('en-us');
357              
358             # my $address_city_suffix = $faker->address_city_suffix;
359              
360             # "borough"
361              
362             # $address_city_suffix = $faker->address_city_suffix;
363              
364             # "view"
365              
366             # $address_city_suffix = $faker->address_city_suffix;
367              
368             # "haven"
369              
370             =back
371              
372             =cut
373              
374             =head2 address_country_name
375              
376             address_country_name(HashRef $data) (Str)
377              
378             The address_country_name method returns a random address country name.
379              
380             I>
381              
382             =over 4
383              
384             =item address_country_name example 1
385              
386             package main;
387              
388             use Faker;
389              
390             my $faker = Faker->new('en-us');
391              
392             # my $address_country_name = $faker->address_country_name;
393              
394             # "Greenland"
395              
396             # $address_country_name = $faker->address_country_name;
397              
398             # "Ireland"
399              
400             # $address_country_name = $faker->address_country_name;
401              
402             # "Svalbard & Jan Mayen Islands"
403              
404             =back
405              
406             =cut
407              
408             =head2 address_latitude
409              
410             address_latitude(HashRef $data) (Str)
411              
412             The address_latitude method returns a random address latitude.
413              
414             I>
415              
416             =over 4
417              
418             =item address_latitude example 1
419              
420             package main;
421              
422             use Faker;
423              
424             my $faker = Faker->new('en-us');
425              
426             # my $address_latitude = $faker->address_latitude;
427              
428             # 30.843133
429              
430             # $address_latitude = $faker->address_latitude;
431              
432             # 77.079663
433              
434             # $address_latitude = $faker->address_latitude;
435              
436             # -41.660985
437              
438             =back
439              
440             =cut
441              
442             =head2 address_line1
443              
444             address_line1(HashRef $data) (Str)
445              
446             The address_line1 method returns a random address line1.
447              
448             I>
449              
450             =over 4
451              
452             =item address_line1 example 1
453              
454             package main;
455              
456             use Faker;
457              
458             my $faker = Faker->new('en-us');
459              
460             # my $address_line1 = $faker->address_line1;
461              
462             # "44084 Mayer Brook"
463              
464             # $address_line1 = $faker->address_line1;
465              
466             # "4 Amalia Terrace"
467              
468             # $address_line1 = $faker->address_line1;
469              
470             # "20370 Emard Street"
471              
472             =back
473              
474             =cut
475              
476             =head2 address_line2
477              
478             address_line2(HashRef $data) (Str)
479              
480             The address_line2 method returns a random address line2.
481              
482             I>
483              
484             =over 4
485              
486             =item address_line2 example 1
487              
488             package main;
489              
490             use Faker;
491              
492             my $faker = Faker->new('en-us');
493              
494             # my $address_line2 = $faker->address_line2;
495              
496             # "Mailbox 1408"
497              
498             # $address_line2 = $faker->address_line2;
499              
500             # "Mailbox 684"
501              
502             # $address_line2 = $faker->address_line2;
503              
504             # "Suite 076"
505              
506             =back
507              
508             =cut
509              
510             =head2 address_lines
511              
512             address_lines(HashRef $data) (Str)
513              
514             The address_lines method returns a random address lines.
515              
516             I>
517              
518             =over 4
519              
520             =item address_lines example 1
521              
522             package main;
523              
524             use Faker;
525              
526             my $faker = Faker->new('en-us');
527              
528             # my $address_lines = $faker->address_lines;
529              
530             # "4 Koelpin Plaza Unit 694\nWest Viviane, IA 37022"
531              
532             # $address_lines = $faker->address_lines;
533              
534             # "90558 Greenholt Orchard\nApt. 250\nPfannerstillberg, New Mexico 52836"
535              
536             # $address_lines = $faker->address_lines;
537              
538             # "68768 Weissnat Point\nRitchieburgh, New Mexico 53892"
539              
540             =back
541              
542             =cut
543              
544             =head2 address_longitude
545              
546             address_longitude(HashRef $data) (Str)
547              
548             The address_longitude method returns a random address longitude.
549              
550             I>
551              
552             =over 4
553              
554             =item address_longitude example 1
555              
556             package main;
557              
558             use Faker;
559              
560             my $faker = Faker->new('en-us');
561              
562             # my $address_longitude = $faker->address_longitude;
563              
564             # 30.843133
565              
566             # $address_longitude = $faker->address_longitude;
567              
568             # 77.079663
569              
570             # $address_longitude = $faker->address_longitude;
571              
572             # -41.660985
573              
574             =back
575              
576             =cut
577              
578             =head2 address_number
579              
580             address_number(HashRef $data) (Str)
581              
582             The address_number method returns a random address number.
583              
584             I>
585              
586             =over 4
587              
588             =item address_number example 1
589              
590             package main;
591              
592             use Faker;
593              
594             my $faker = Faker->new('en-us');
595              
596             # my $address_number = $faker->address_number;
597              
598             # 8140
599              
600             # $address_number = $faker->address_number;
601              
602             # 5684
603              
604             # $address_number = $faker->address_number;
605              
606             # 57694
607              
608             =back
609              
610             =cut
611              
612             =head2 address_postal_code
613              
614             address_postal_code(HashRef $data) (Str)
615              
616             The address_postal_code method returns a random address postal code.
617              
618             I>
619              
620             =over 4
621              
622             =item address_postal_code example 1
623              
624             package main;
625              
626             use Faker;
627              
628             my $faker = Faker->new('en-us');
629              
630             # my $address_postal_code = $faker->address_postal_code;
631              
632             # 14084
633              
634             # $address_postal_code = $faker->address_postal_code;
635              
636             # "84550-7694"
637              
638             # $address_postal_code = $faker->address_postal_code;
639              
640             # 43908
641              
642             =back
643              
644             =cut
645              
646             =head2 address_region_name
647              
648             address_region_name(HashRef $data) (Str)
649              
650             The address_region_name method returns a random address region name.
651              
652             I>
653              
654             =over 4
655              
656             =item address_region_name example 1
657              
658             package main;
659              
660             use Faker;
661              
662             my $faker = Faker->new('en-us');
663              
664             # my $address_region_name = $faker->address_region_name;
665              
666             # "Massachusetts"
667              
668             # $address_region_name = $faker->address_region_name;
669              
670             # "MO"
671              
672             # $address_region_name = $faker->address_region_name;
673              
674             # "NE"
675              
676             =back
677              
678             =cut
679              
680             =head2 address_state_abbr
681              
682             address_state_abbr(HashRef $data) (Str)
683              
684             The address_state_abbr method returns a random address state abbr.
685              
686             I>
687              
688             =over 4
689              
690             =item address_state_abbr example 1
691              
692             package main;
693              
694             use Faker;
695              
696             my $faker = Faker->new('en-us');
697              
698             # my $address_state_abbr = $faker->address_state_abbr;
699              
700             # "KY"
701              
702             # $address_state_abbr = $faker->address_state_abbr;
703              
704             # "ME"
705              
706             # $address_state_abbr = $faker->address_state_abbr;
707              
708             # "TX"
709              
710             =back
711              
712             =cut
713              
714             =head2 address_state_name
715              
716             address_state_name(HashRef $data) (Str)
717              
718             The address_state_name method returns a random address state name.
719              
720             I>
721              
722             =over 4
723              
724             =item address_state_name example 1
725              
726             package main;
727              
728             use Faker;
729              
730             my $faker = Faker->new('en-us');
731              
732             # my $address_state_name = $faker->address_state_name;
733              
734             # "Kentucky"
735              
736             # $address_state_name = $faker->address_state_name;
737              
738             # "Massachusetts"
739              
740             # $address_state_name = $faker->address_state_name;
741              
742             # "Texas"
743              
744             =back
745              
746             =cut
747              
748             =head2 address_street_address
749              
750             address_street_address(HashRef $data) (Str)
751              
752             The address_street_address method returns a random address street address.
753              
754             I>
755              
756             =over 4
757              
758             =item address_street_address example 1
759              
760             package main;
761              
762             use Faker;
763              
764             my $faker = Faker->new('en-us');
765              
766             # my $address_street_address = $faker->address_street_address;
767              
768             # "4084 Mayer Brook Suite 94"
769              
770             # $address_street_address = $faker->address_street_address;
771              
772             # "9908 Mustafa Harbor Suite 828"
773              
774             # $address_street_address = $faker->address_street_address;
775              
776             # "958 Greenholt Orchard"
777              
778             =back
779              
780             =cut
781              
782             =head2 address_street_name
783              
784             address_street_name(HashRef $data) (Str)
785              
786             The address_street_name method returns a random address street name.
787              
788             I>
789              
790             =over 4
791              
792             =item address_street_name example 1
793              
794             package main;
795              
796             use Faker;
797              
798             my $faker = Faker->new('en-us');
799              
800             # my $address_street_name = $faker->address_street_name;
801              
802             # "Russel Parkway"
803              
804             # $address_street_name = $faker->address_street_name;
805              
806             # "Mayer Brook"
807              
808             # $address_street_name = $faker->address_street_name;
809              
810             # "Kuhic Path"
811              
812             =back
813              
814             =cut
815              
816             =head2 address_street_suffix
817              
818             address_street_suffix(HashRef $data) (Str)
819              
820             The address_street_suffix method returns a random address street suffix.
821              
822             I>
823              
824             =over 4
825              
826             =item address_street_suffix example 1
827              
828             package main;
829              
830             use Faker;
831              
832             my $faker = Faker->new('en-us');
833              
834             # my $address_street_suffix = $faker->address_street_suffix;
835              
836             # "Key"
837              
838             # $address_street_suffix = $faker->address_street_suffix;
839              
840             # "Mission"
841              
842             # $address_street_suffix = $faker->address_street_suffix;
843              
844             # "Street"
845              
846             =back
847              
848             =cut
849              
850             =head2 cache
851              
852             cache(Str $method, Any @args) (Str)
853              
854             The cache method dispatches to the method specified, caches the method name and
855             return value, and returns the value. Subsequent calls will return the cached
856             value.
857              
858             I>
859              
860             =over 4
861              
862             =item cache example 1
863              
864             package main;
865              
866             use Faker;
867              
868             my $faker = Faker->new('en-us');
869              
870             # my $cache = $faker->cache('person_name');
871              
872             # "Keeley Balistreri"
873              
874             # $cache = $faker->cache('person_name');
875              
876             # "Keeley Balistreri"
877              
878             =back
879              
880             =over 4
881              
882             =item cache example 2
883              
884             package main;
885              
886             use Faker;
887              
888             my $faker = Faker->new('en-us');
889              
890             # my $cache = $faker->cache('company_tagline');
891              
892             # "iterate back-end content"
893              
894             # $cache = $faker->cache('company_tagline');
895              
896             # "iterate back-end content"
897              
898             =back
899              
900             =cut
901              
902             =head2 color_hex_code
903              
904             color_hex_code(HashRef $data) (Str)
905              
906             The color_hex_code method returns a random color hex code.
907              
908             I>
909              
910             =over 4
911              
912             =item color_hex_code example 1
913              
914             package main;
915              
916             use Faker;
917              
918             my $faker = Faker->new('en-us');
919              
920             # my $color_hex_code = $faker->color_hex_code;
921              
922             # "#57bb49"
923              
924             # $color_hex_code = $faker->color_hex_code;
925              
926             # "#6c1e68"
927              
928             # $color_hex_code = $faker->color_hex_code;
929              
930             # "#db3fb2"
931              
932             =back
933              
934             =cut
935              
936             =head2 color_name
937              
938             color_name(HashRef $data) (Str)
939              
940             The color_name method returns a random color name.
941              
942             I>
943              
944             =over 4
945              
946             =item color_name example 1
947              
948             package main;
949              
950             use Faker;
951              
952             my $faker = Faker->new('en-us');
953              
954             # my $color_name = $faker->color_name;
955              
956             # "GhostWhite"
957              
958             # $color_name = $faker->color_name;
959              
960             # "Khaki"
961              
962             # $color_name = $faker->color_name;
963              
964             # "SeaGreen"
965              
966             =back
967              
968             =cut
969              
970             =head2 color_rgb_colorset
971              
972             color_rgb_colorset(HashRef $data) (Str)
973              
974             The color_rgb_colorset method returns a random color rgb colorset.
975              
976             I>
977              
978             =over 4
979              
980             =item color_rgb_colorset example 1
981              
982             package main;
983              
984             use Faker;
985              
986             my $faker = Faker->new('en-us');
987              
988             # my $color_rgb_colorset = $faker->color_rgb_colorset;
989              
990             # [28, 112, 22]
991              
992             # $color_rgb_colorset = $faker->color_rgb_colorset;
993              
994             # [219, 63, 178]
995              
996             # $color_rgb_colorset = $faker->color_rgb_colorset;
997              
998             # [176, 217, 21]
999              
1000             =back
1001              
1002             =cut
1003              
1004             =head2 color_rgb_colorset_css
1005              
1006             color_rgb_colorset_css(HashRef $data) (Str)
1007              
1008             The color_rgb_colorset_css method returns a random color rgb colorset css.
1009              
1010             I>
1011              
1012             =over 4
1013              
1014             =item color_rgb_colorset_css example 1
1015              
1016             package main;
1017              
1018             use Faker;
1019              
1020             my $faker = Faker->new('en-us');
1021              
1022             # my $color_rgb_colorset_css = $faker->color_rgb_colorset_css;
1023              
1024             # "rgb(108, 30, 104)"
1025              
1026             # $color_rgb_colorset_css = $faker->color_rgb_colorset_css;
1027              
1028             # "rgb(122, 147, 147)"
1029              
1030             # $color_rgb_colorset_css = $faker->color_rgb_colorset_css;
1031              
1032             # "rgb(147, 224, 22)"
1033              
1034             =back
1035              
1036             =cut
1037              
1038             =head2 color_safe_hex_code
1039              
1040             color_safe_hex_code(HashRef $data) (Str)
1041              
1042             The color_safe_hex_code method returns a random color safe hex code.
1043              
1044             I>
1045              
1046             =over 4
1047              
1048             =item color_safe_hex_code example 1
1049              
1050             package main;
1051              
1052             use Faker;
1053              
1054             my $faker = Faker->new('en-us');
1055              
1056             # my $color_safe_hex_code = $faker->color_safe_hex_code;
1057              
1058             # "#ff0057"
1059              
1060             # $color_safe_hex_code = $faker->color_safe_hex_code;
1061              
1062             # "#ff006c"
1063              
1064             # $color_safe_hex_code = $faker->color_safe_hex_code;
1065              
1066             # "#ff00db"
1067              
1068             =back
1069              
1070             =cut
1071              
1072             =head2 color_safe_name
1073              
1074             color_safe_name(HashRef $data) (Str)
1075              
1076             The color_safe_name method returns a random color safe name.
1077              
1078             I>
1079              
1080             =over 4
1081              
1082             =item color_safe_name example 1
1083              
1084             package main;
1085              
1086             use Faker;
1087              
1088             my $faker = Faker->new('en-us');
1089              
1090             # my $color_safe_name = $faker->color_safe_name;
1091              
1092             # "purple"
1093              
1094             # $color_safe_name = $faker->color_safe_name;
1095              
1096             # "teal"
1097              
1098             # $color_safe_name = $faker->color_safe_name;
1099              
1100             # "fuchsia"
1101              
1102             =back
1103              
1104             =cut
1105              
1106             =head2 company_description
1107              
1108             company_description(HashRef $data) (Str)
1109              
1110             The company_description method returns a random company description.
1111              
1112             I>
1113              
1114             =over 4
1115              
1116             =item company_description example 1
1117              
1118             package main;
1119              
1120             use Faker;
1121              
1122             my $faker = Faker->new('en-us');
1123              
1124             # my $company_description = $faker->company_description;
1125              
1126             # "Excels at full-range synchronised implementations"
1127              
1128             # $company_description = $faker->company_description;
1129              
1130             # "Provides logistical ameliorated methodologies"
1131              
1132             # $company_description = $faker->company_description;
1133              
1134             # "Offering hybrid future-proofed applications"
1135              
1136             =back
1137              
1138             =cut
1139              
1140             =head2 company_name
1141              
1142             company_name(HashRef $data) (Str)
1143              
1144             The company_name method returns a random company name.
1145              
1146             I>
1147              
1148             =over 4
1149              
1150             =item company_name example 1
1151              
1152             package main;
1153              
1154             use Faker;
1155              
1156             my $faker = Faker->new('en-us');
1157              
1158             # my $company_name = $faker->company_name;
1159              
1160             # "Johnston-Steuber"
1161              
1162             # $company_name = $faker->company_name;
1163              
1164             # "Skiles-Mayer"
1165              
1166             # $company_name = $faker->company_name;
1167              
1168             # "Miller and Sons"
1169              
1170             =back
1171              
1172             =cut
1173              
1174             =head2 company_name_suffix
1175              
1176             company_name_suffix(HashRef $data) (Str)
1177              
1178             The company_name_suffix method returns a random company name suffix.
1179              
1180             I>
1181              
1182             =over 4
1183              
1184             =item company_name_suffix example 1
1185              
1186             package main;
1187              
1188             use Faker;
1189              
1190             my $faker = Faker->new('en-us');
1191              
1192             # my $company_name_suffix = $faker->company_name_suffix;
1193              
1194             # "Inc."
1195              
1196             # $company_name_suffix = $faker->company_name_suffix;
1197              
1198             # "Incorporated"
1199              
1200             # $company_name_suffix = $faker->company_name_suffix;
1201              
1202             # "Ventures"
1203              
1204             =back
1205              
1206             =cut
1207              
1208             =head2 company_tagline
1209              
1210             company_tagline(HashRef $data) (Str)
1211              
1212             The company_tagline method returns a random company tagline.
1213              
1214             I>
1215              
1216             =over 4
1217              
1218             =item company_tagline example 1
1219              
1220             package main;
1221              
1222             use Faker;
1223              
1224             my $faker = Faker->new('en-us');
1225              
1226             # my $company_tagline = $faker->company_tagline;
1227              
1228             # "transform revolutionary supply-chains"
1229              
1230             # $company_tagline = $faker->company_tagline;
1231              
1232             # "generate front-end web-readiness"
1233              
1234             # $company_tagline = $faker->company_tagline;
1235              
1236             # "iterate back-end content"
1237              
1238             =back
1239              
1240             =cut
1241              
1242             =head2 internet_domain_name
1243              
1244             internet_domain_name(HashRef $data) (Str)
1245              
1246             The internet_domain_name method returns a random internet domain name.
1247              
1248             I>
1249              
1250             =over 4
1251              
1252             =item internet_domain_name example 1
1253              
1254             package main;
1255              
1256             use Faker;
1257              
1258             my $faker = Faker->new('en-us');
1259              
1260             # my $internet_domain_name = $faker->internet_domain_name;
1261              
1262             # "steuber-krajcik.org"
1263              
1264             # $internet_domain_name = $faker->internet_domain_name;
1265              
1266             # "miller-and-sons.com"
1267              
1268             # $internet_domain_name = $faker->internet_domain_name;
1269              
1270             # "witting-entertainment.com"
1271              
1272             =back
1273              
1274             =cut
1275              
1276             =head2 internet_domain_tld
1277              
1278             internet_domain_tld(HashRef $data) (Str)
1279              
1280             The internet_domain_tld method returns a random internet domain tld.
1281              
1282             I>
1283              
1284             =over 4
1285              
1286             =item internet_domain_tld example 1
1287              
1288             package main;
1289              
1290             use Faker;
1291              
1292             my $faker = Faker->new('en-us');
1293              
1294             # my $internet_domain_tld = $faker->internet_domain_tld;
1295              
1296             # "com"
1297              
1298             # $internet_domain_tld = $faker->internet_domain_tld;
1299              
1300             # "com"
1301              
1302             # $internet_domain_tld = $faker->internet_domain_tld;
1303              
1304             # "org"
1305              
1306             =back
1307              
1308             =cut
1309              
1310             =head2 internet_domain_word
1311              
1312             internet_domain_word(HashRef $data) (Str)
1313              
1314             The internet_domain_word method returns a random internet domain word.
1315              
1316             I>
1317              
1318             =over 4
1319              
1320             =item internet_domain_word example 1
1321              
1322             package main;
1323              
1324             use Faker;
1325              
1326             my $faker = Faker->new('en-us');
1327              
1328             # my $internet_domain_word = $faker->internet_domain_word;
1329              
1330             # "bode-and-sons"
1331              
1332             # $internet_domain_word = $faker->internet_domain_word;
1333              
1334             # "mayer-balistreri-and-miller"
1335              
1336             # $internet_domain_word = $faker->internet_domain_word;
1337              
1338             # "kerluke-waelchi"
1339              
1340             =back
1341              
1342             =cut
1343              
1344             =head2 internet_email_address
1345              
1346             internet_email_address(HashRef $data) (Str)
1347              
1348             The internet_email_address method returns a random internet email address.
1349              
1350             I>
1351              
1352             =over 4
1353              
1354             =item internet_email_address example 1
1355              
1356             package main;
1357              
1358             use Faker;
1359              
1360             my $faker = Faker->new('en-us');
1361              
1362             # my $internet_email_address = $faker->internet_email_address;
1363              
1364             # "russel54\@mayer-balistreri-and-miller.com"
1365              
1366             # $internet_email_address = $faker->internet_email_address;
1367              
1368             # "viviane82\@rempel-entertainment.com"
1369              
1370             # $internet_email_address = $faker->internet_email_address;
1371              
1372             # "yborer\@outlook.com"
1373              
1374             =back
1375              
1376             =cut
1377              
1378             =head2 internet_email_domain
1379              
1380             internet_email_domain(HashRef $data) (Str)
1381              
1382             The internet_email_domain method returns a random internet email domain.
1383              
1384             I>
1385              
1386             =over 4
1387              
1388             =item internet_email_domain example 1
1389              
1390             package main;
1391              
1392             use Faker;
1393              
1394             my $faker = Faker->new('en-us');
1395              
1396             # my $internet_email_domain = $faker->internet_email_domain;
1397              
1398             # "icloud.com"
1399              
1400             # $internet_email_domain = $faker->internet_email_domain;
1401              
1402             # "icloud.com"
1403              
1404             # $internet_email_domain = $faker->internet_email_domain;
1405              
1406             # "yahoo.com"
1407              
1408             =back
1409              
1410             =cut
1411              
1412             =head2 internet_ip_address
1413              
1414             internet_ip_address(HashRef $data) (Str)
1415              
1416             The internet_ip_address method returns a random internet ip address.
1417              
1418             I>
1419              
1420             =over 4
1421              
1422             =item internet_ip_address example 1
1423              
1424             package main;
1425              
1426             use Faker;
1427              
1428             my $faker = Faker->new('en-us');
1429              
1430             # my $internet_ip_address = $faker->internet_ip_address;
1431              
1432             # "108.20.219.127"
1433              
1434             # $internet_ip_address = $faker->internet_ip_address;
1435              
1436             # "7680:93e0:88b2:06a0:c512:99e4:e8a9:7d48"
1437              
1438             # $internet_ip_address = $faker->internet_ip_address;
1439              
1440             # "89.236.15.220"
1441              
1442             =back
1443              
1444             =cut
1445              
1446             =head2 internet_ip_address_v4
1447              
1448             internet_ip_address_v4(HashRef $data) (Str)
1449              
1450             The internet_ip_address_v4 method returns a random internet ip address v4.
1451              
1452             I>
1453              
1454             =over 4
1455              
1456             =item internet_ip_address_v4 example 1
1457              
1458             package main;
1459              
1460             use Faker;
1461              
1462             my $faker = Faker->new('en-us');
1463              
1464             # my $internet_ip_address_v4 = $faker->internet_ip_address_v4;
1465              
1466             # "87.28.108.20"
1467              
1468             # $internet_ip_address_v4 = $faker->internet_ip_address_v4;
1469              
1470             # "127.122.176.213"
1471              
1472             # $internet_ip_address_v4 = $faker->internet_ip_address_v4;
1473              
1474             # "147.136.6.197"
1475              
1476             =back
1477              
1478             =cut
1479              
1480             =head2 internet_ip_address_v6
1481              
1482             internet_ip_address_v6(HashRef $data) (Str)
1483              
1484             The internet_ip_address_v6 method returns a random internet ip address v6.
1485              
1486             I>
1487              
1488             =over 4
1489              
1490             =item internet_ip_address_v6 example 1
1491              
1492             package main;
1493              
1494             use Faker;
1495              
1496             my $faker = Faker->new('en-us');
1497              
1498             # my $internet_ip_address_v6 = $faker->internet_ip_address_v6;
1499              
1500             # "57bb:1c70:6c1e:14c3:db3f:7fb1:7a93:b0d9"
1501              
1502             # $internet_ip_address_v6 = $faker->internet_ip_address_v6;
1503              
1504             # "7680:93e0:88b2:06a0:c512:99e4:e8a9:7d48"
1505              
1506             # $internet_ip_address_v6 = $faker->internet_ip_address_v6;
1507              
1508             # "7f27:7009:5984:ec03:0f75:dc22:f8d4:d951"
1509              
1510             =back
1511              
1512             =cut
1513              
1514             =head2 internet_url
1515              
1516             internet_url(HashRef $data) (Str)
1517              
1518             The internet_url method returns a random internet url.
1519              
1520             I>
1521              
1522             =over 4
1523              
1524             =item internet_url example 1
1525              
1526             package main;
1527              
1528             use Faker;
1529              
1530             my $faker = Faker->new('en-us');
1531              
1532             # my $internet_url = $faker->internet_url;
1533              
1534             # "https://krajcik-skiles-and-mayer.com/"
1535              
1536             # $internet_url = $faker->internet_url;
1537              
1538             # "http://heidenreich-beier.co/"
1539              
1540             # $internet_url = $faker->internet_url;
1541              
1542             # "https://goldner-mann-and-emard.org/"
1543              
1544             =back
1545              
1546             =cut
1547              
1548             =head2 jargon_adjective
1549              
1550             jargon_adjective(HashRef $data) (Str)
1551              
1552             The jargon_adjective method returns a random jargon adjective.
1553              
1554             I>
1555              
1556             =over 4
1557              
1558             =item jargon_adjective example 1
1559              
1560             package main;
1561              
1562             use Faker;
1563              
1564             my $faker = Faker->new('en-us');
1565              
1566             # my $jargon_adjective = $faker->jargon_adjective;
1567              
1568             # "virtual"
1569              
1570             # $jargon_adjective = $faker->jargon_adjective;
1571              
1572             # "killer"
1573              
1574             # $jargon_adjective = $faker->jargon_adjective;
1575              
1576             # "cutting-edge"
1577              
1578             =back
1579              
1580             =cut
1581              
1582             =head2 jargon_adverb
1583              
1584             jargon_adverb(HashRef $data) (Str)
1585              
1586             The jargon_adverb method returns a random jargon adverb.
1587              
1588             I>
1589              
1590             =over 4
1591              
1592             =item jargon_adverb example 1
1593              
1594             package main;
1595              
1596             use Faker;
1597              
1598             my $faker = Faker->new('en-us');
1599              
1600             # my $jargon_adverb = $faker->jargon_adverb;
1601              
1602             # "future-proofed"
1603              
1604             # $jargon_adverb = $faker->jargon_adverb;
1605              
1606             # "managed"
1607              
1608             # $jargon_adverb = $faker->jargon_adverb;
1609              
1610             # "synchronised"
1611              
1612             =back
1613              
1614             =cut
1615              
1616             =head2 jargon_noun
1617              
1618             jargon_noun(HashRef $data) (Str)
1619              
1620             The jargon_noun method returns a random jargon noun.
1621              
1622             I>
1623              
1624             =over 4
1625              
1626             =item jargon_noun example 1
1627              
1628             package main;
1629              
1630             use Faker;
1631              
1632             my $faker = Faker->new('en-us');
1633              
1634             # my $jargon_noun = $faker->jargon_noun;
1635              
1636             # "action-items"
1637              
1638             # $jargon_noun = $faker->jargon_noun;
1639              
1640             # "technologies"
1641              
1642             # $jargon_noun = $faker->jargon_noun;
1643              
1644             # "applications"
1645              
1646             =back
1647              
1648             =cut
1649              
1650             =head2 jargon_term_prefix
1651              
1652             jargon_term_prefix(HashRef $data) (Str)
1653              
1654             The jargon_term_prefix method returns a random jargon term prefix.
1655              
1656             I>
1657              
1658             =over 4
1659              
1660             =item jargon_term_prefix example 1
1661              
1662             package main;
1663              
1664             use Faker;
1665              
1666             my $faker = Faker->new('en-us');
1667              
1668             # my $jargon_term_prefix = $faker->jargon_term_prefix;
1669              
1670             # "encompassing"
1671              
1672             # $jargon_term_prefix = $faker->jargon_term_prefix;
1673              
1674             # "full-range"
1675              
1676             # $jargon_term_prefix = $faker->jargon_term_prefix;
1677              
1678             # "systematic"
1679              
1680             =back
1681              
1682             =cut
1683              
1684             =head2 jargon_term_suffix
1685              
1686             jargon_term_suffix(HashRef $data) (Str)
1687              
1688             The jargon_term_suffix method returns a random jargon term suffix.
1689              
1690             I>
1691              
1692             =over 4
1693              
1694             =item jargon_term_suffix example 1
1695              
1696             package main;
1697              
1698             use Faker;
1699              
1700             my $faker = Faker->new('en-us');
1701              
1702             # my $jargon_term_suffix = $faker->jargon_term_suffix;
1703              
1704             # "flexibilities"
1705              
1706             # $jargon_term_suffix = $faker->jargon_term_suffix;
1707              
1708             # "graphical user interfaces"
1709              
1710             # $jargon_term_suffix = $faker->jargon_term_suffix;
1711              
1712             # "standardization"
1713              
1714             =back
1715              
1716             =cut
1717              
1718             =head2 jargon_verb
1719              
1720             jargon_verb(HashRef $data) (Str)
1721              
1722             The jargon_verb method returns a random jargon verb.
1723              
1724             I>
1725              
1726             =over 4
1727              
1728             =item jargon_verb example 1
1729              
1730             package main;
1731              
1732             use Faker;
1733              
1734             my $faker = Faker->new('en-us');
1735              
1736             # my $jargon_verb = $faker->jargon_verb;
1737              
1738             # "harness"
1739              
1740             # $jargon_verb = $faker->jargon_verb;
1741              
1742             # "strategize"
1743              
1744             # $jargon_verb = $faker->jargon_verb;
1745              
1746             # "exploit"
1747              
1748             =back
1749              
1750             =cut
1751              
1752             =head2 lorem_paragraph
1753              
1754             lorem_paragraph(HashRef $data) (Str)
1755              
1756             The lorem_paragraph method returns a random lorem paragraph.
1757              
1758             I>
1759              
1760             =over 4
1761              
1762             =item lorem_paragraph example 1
1763              
1764             package main;
1765              
1766             use Faker;
1767              
1768             my $faker = Faker->new('en-us');
1769              
1770             # my $lorem_paragraph = $faker->lorem_paragraph;
1771              
1772             # "deleniti fugiat in accusantium animi corrupti dolores. eos ..."
1773              
1774             # $lorem_paragraph = $faker->lorem_paragraph;
1775              
1776             # "ducimus placeat autem ut sit adipisci asperiores quae ipsum..."
1777              
1778             # $lorem_paragraph = $faker->lorem_paragraph;
1779              
1780             # "dignissimos est magni quia aut et hic eos architecto repudi..."
1781              
1782             =back
1783              
1784             =cut
1785              
1786             =head2 lorem_paragraphs
1787              
1788             lorem_paragraphs(HashRef $data) (Str)
1789              
1790             The lorem_paragraphs method returns a random lorem paragraphs.
1791              
1792             I>
1793              
1794             =over 4
1795              
1796             =item lorem_paragraphs example 1
1797              
1798             package main;
1799              
1800             use Faker;
1801              
1802             my $faker = Faker->new('en-us');
1803              
1804             # my $lorem_paragraphs = $faker->lorem_paragraphs;
1805              
1806             # "eligendi laudantium provident assumenda voluptates sed iu..."
1807              
1808             # $lorem_paragraphs = $faker->lorem_paragraphs;
1809              
1810             # "accusantium ex pariatur perferendis voluptate iusto iure fu..."
1811              
1812             # $lorem_paragraphs = $faker->lorem_paragraphs;
1813              
1814             # "sit ut molestiae consequatur error tempora inventore est so..."
1815              
1816             =back
1817              
1818             =cut
1819              
1820             =head2 lorem_sentence
1821              
1822             lorem_sentence(HashRef $data) (Str)
1823              
1824             The lorem_sentence method returns a random lorem sentence.
1825              
1826             I>
1827              
1828             =over 4
1829              
1830             =item lorem_sentence example 1
1831              
1832             package main;
1833              
1834             use Faker;
1835              
1836             my $faker = Faker->new('en-us');
1837              
1838             # my $lorem_sentence = $faker->lorem_sentence;
1839              
1840             # "vitae et eligendi laudantium provident assumenda voluptates..."
1841              
1842             # $lorem_sentence = $faker->lorem_sentence;
1843              
1844             # "aspernatur qui ad error numquam illum sunt cupiditate recus..."
1845              
1846             # $lorem_sentence = $faker->lorem_sentence;
1847              
1848             # "incidunt ut ratione sequi non illum laborum dolorum et earu..."
1849              
1850             =back
1851              
1852             =cut
1853              
1854             =head2 lorem_sentences
1855              
1856             lorem_sentences(HashRef $data) (Str)
1857              
1858             The lorem_sentences method returns a random lorem sentences.
1859              
1860             I>
1861              
1862             =over 4
1863              
1864             =item lorem_sentences example 1
1865              
1866             package main;
1867              
1868             use Faker;
1869              
1870             my $faker = Faker->new('en-us');
1871              
1872             # my $lorem_sentences = $faker->lorem_sentences;
1873              
1874             # "vero deleniti fugiat in accusantium animi corrupti. et eos ..."
1875              
1876             # $lorem_sentences = $faker->lorem_sentences;
1877              
1878             # "enim accusantium aliquid id reprehenderit consequatur ducim..."
1879              
1880             # $lorem_sentences = $faker->lorem_sentences;
1881              
1882             # "reprehenderit ut autem cumque ea sint dolorem impedit et qu..."
1883              
1884             =back
1885              
1886             =cut
1887              
1888             =head2 lorem_word
1889              
1890             lorem_word(HashRef $data) (Str)
1891              
1892             The lorem_word method returns a random lorem word.
1893              
1894             I>
1895              
1896             =over 4
1897              
1898             =item lorem_word example 1
1899              
1900             package main;
1901              
1902             use Faker;
1903              
1904             my $faker = Faker->new('en-us');
1905              
1906             # my $lorem_word = $faker->lorem_word;
1907              
1908             # "nisi"
1909              
1910             # $lorem_word = $faker->lorem_word;
1911              
1912             # "nihil"
1913              
1914             # $lorem_word = $faker->lorem_word;
1915              
1916             # "vero"
1917              
1918             =back
1919              
1920             =cut
1921              
1922             =head2 lorem_words
1923              
1924             lorem_words(HashRef $data) (Str)
1925              
1926             The lorem_words method returns a random lorem words.
1927              
1928             I>
1929              
1930             =over 4
1931              
1932             =item lorem_words example 1
1933              
1934             package main;
1935              
1936             use Faker;
1937              
1938             my $faker = Faker->new('en-us');
1939              
1940             # my $lorem_words = $faker->lorem_words;
1941              
1942             # "aut vitae et eligendi laudantium"
1943              
1944             # $lorem_words = $faker->lorem_words;
1945              
1946             # "accusantium animi corrupti dolores aliquid"
1947              
1948             # $lorem_words = $faker->lorem_words;
1949              
1950             # "eos pariatur quia corporis illo"
1951              
1952             =back
1953              
1954             =cut
1955              
1956             =head2 new
1957              
1958             new(Str $data | ArrayRef $data | HashRef $data) (Faker)
1959              
1960             The new method returns a new instance of the class.
1961              
1962             I>
1963              
1964             =over 4
1965              
1966             =item new example 1
1967              
1968             package main;
1969              
1970             use Faker;
1971              
1972             my $faker = Faker->new('en-us');
1973              
1974             # my $first_name = $faker->person_name;
1975              
1976             # "Russel Krajcik"
1977              
1978             =back
1979              
1980             =over 4
1981              
1982             =item new example 2
1983              
1984             package main;
1985              
1986             use Faker;
1987              
1988             my $faker = Faker->new(['en-us', 'es-es']);
1989              
1990             # my $first_name = $faker->person_name;
1991              
1992             # "Rafael Loera"
1993              
1994             =back
1995              
1996             =over 4
1997              
1998             =item new example 3
1999              
2000             package main;
2001              
2002             use Faker;
2003              
2004             my $faker = Faker->new({locales => ['en-us']});
2005              
2006             # my $first_name = $faker->person_name;
2007              
2008             # "Russel Krajcik"
2009              
2010             =back
2011              
2012             =cut
2013              
2014             =head2 payment_card_american_express
2015              
2016             payment_card_american_express(HashRef $data) (Str)
2017              
2018             The payment_card_american_express method returns a random payment card american express.
2019              
2020             I>
2021              
2022             =over 4
2023              
2024             =item payment_card_american_express example 1
2025              
2026             package main;
2027              
2028             use Faker;
2029              
2030             my $faker = Faker->new('en-us');
2031              
2032             # my $payment_card_american_express = $faker->payment_card_american_express;
2033              
2034             # 34140844684550
2035              
2036             # $payment_card_american_express = $faker->payment_card_american_express;
2037              
2038             # 37945443908982
2039              
2040             # $payment_card_american_express = $faker->payment_card_american_express;
2041              
2042             # 34370225828820
2043              
2044             =back
2045              
2046             =cut
2047              
2048             =head2 payment_card_discover
2049              
2050             payment_card_discover(HashRef $data) (Str)
2051              
2052             The payment_card_discover method returns a random payment card discover.
2053              
2054             I>
2055              
2056             =over 4
2057              
2058             =item payment_card_discover example 1
2059              
2060             package main;
2061              
2062             use Faker;
2063              
2064             my $faker = Faker->new('en-us');
2065              
2066             # my $payment_card_discover = $faker->payment_card_discover;
2067              
2068             # 601131408446845
2069              
2070             # $payment_card_discover = $faker->payment_card_discover;
2071              
2072             # 601107694544390
2073              
2074             # $payment_card_discover = $faker->payment_card_discover;
2075              
2076             # 601198220370225
2077              
2078             =back
2079              
2080             =cut
2081              
2082             =head2 payment_card_expiration
2083              
2084             payment_card_expiration(HashRef $data) (Str)
2085              
2086             The payment_card_expiration method returns a random payment card expiration.
2087              
2088             I>
2089              
2090             =over 4
2091              
2092             =item payment_card_expiration example 1
2093              
2094             package main;
2095              
2096             use Faker;
2097              
2098             my $faker = Faker->new('en-us');
2099              
2100             # my $payment_card_expiration = $faker->payment_card_expiration;
2101              
2102             # "02/24"
2103              
2104             # $payment_card_expiration = $faker->payment_card_expiration;
2105              
2106             # "11/23"
2107              
2108             # $payment_card_expiration = $faker->payment_card_expiration;
2109              
2110             # "09/24"
2111              
2112             =back
2113              
2114             =cut
2115              
2116             =head2 payment_card_mastercard
2117              
2118             payment_card_mastercard(HashRef $data) (Str)
2119              
2120             The payment_card_mastercard method returns a random payment card mastercard.
2121              
2122             I>
2123              
2124             =over 4
2125              
2126             =item payment_card_mastercard example 1
2127              
2128             package main;
2129              
2130             use Faker;
2131              
2132             my $faker = Faker->new('en-us');
2133              
2134             # my $payment_card_mastercard = $faker->payment_card_mastercard;
2135              
2136             # 521408446845507
2137              
2138             # $payment_card_mastercard = $faker->payment_card_mastercard;
2139              
2140             # 554544390898220
2141              
2142             # $payment_card_mastercard = $faker->payment_card_mastercard;
2143              
2144             # 540225828820558
2145              
2146             =back
2147              
2148             =cut
2149              
2150             =head2 payment_card_number
2151              
2152             payment_card_number(HashRef $data) (Str)
2153              
2154             The payment_card_number method returns a random payment card number.
2155              
2156             I>
2157              
2158             =over 4
2159              
2160             =item payment_card_number example 1
2161              
2162             package main;
2163              
2164             use Faker;
2165              
2166             my $faker = Faker->new('en-us');
2167              
2168             # my $payment_card_number = $faker->payment_card_number;
2169              
2170             # 453208446845507
2171              
2172             # $payment_card_number = $faker->payment_card_number;
2173              
2174             # 37443908982203
2175              
2176             # $payment_card_number = $faker->payment_card_number;
2177              
2178             # 491658288205589
2179              
2180             =back
2181              
2182             =cut
2183              
2184             =head2 payment_card_visa
2185              
2186             payment_card_visa(HashRef $data) (Str)
2187              
2188             The payment_card_visa method returns a random payment card visa.
2189              
2190             I>
2191              
2192             =over 4
2193              
2194             =item payment_card_visa example 1
2195              
2196             package main;
2197              
2198             use Faker;
2199              
2200             my $faker = Faker->new('en-us');
2201              
2202             # my $payment_card_visa = $faker->payment_card_visa;
2203              
2204             # 453214084468
2205              
2206             # $payment_card_visa = $faker->payment_card_visa;
2207              
2208             # 402400715076
2209              
2210             # $payment_card_visa = $faker->payment_card_visa;
2211              
2212             # 492954439089
2213              
2214             =back
2215              
2216             =cut
2217              
2218             =head2 payment_vendor
2219              
2220             payment_vendor(HashRef $data) (Str)
2221              
2222             The payment_vendor method returns a random payment vendor.
2223              
2224             I>
2225              
2226             =over 4
2227              
2228             =item payment_vendor example 1
2229              
2230             package main;
2231              
2232             use Faker;
2233              
2234             my $faker = Faker->new('en-us');
2235              
2236             # my $payment_vendor = $faker->payment_vendor;
2237              
2238             # "Visa"
2239              
2240             # $payment_vendor = $faker->payment_vendor;
2241              
2242             # "MasterCard"
2243              
2244             # $payment_vendor = $faker->payment_vendor;
2245              
2246             # "American Express"
2247              
2248             =back
2249              
2250             =cut
2251              
2252             =head2 person_first_name
2253              
2254             person_first_name(HashRef $data) (Str)
2255              
2256             The person_first_name method returns a random person first name.
2257              
2258             I>
2259              
2260             =over 4
2261              
2262             =item person_first_name example 1
2263              
2264             package main;
2265              
2266             use Faker;
2267              
2268             my $faker = Faker->new('en-us');
2269              
2270             # my $person_first_name = $faker->person_first_name;
2271              
2272             # "Haskell"
2273              
2274             # $person_first_name = $faker->person_first_name;
2275              
2276             # "Jamison"
2277              
2278             # $person_first_name = $faker->person_first_name;
2279              
2280             # "Keeley"
2281              
2282             =back
2283              
2284             =cut
2285              
2286             =head2 person_formal_name
2287              
2288             person_formal_name(HashRef $data) (Str)
2289              
2290             The person_formal_name method returns a random person formal name.
2291              
2292             I>
2293              
2294             =over 4
2295              
2296             =item person_formal_name example 1
2297              
2298             package main;
2299              
2300             use Faker;
2301              
2302             my $faker = Faker->new('en-us');
2303              
2304             # my $person_formal_name = $faker->person_formal_name;
2305              
2306             # "Russel Krajcik"
2307              
2308             # $person_formal_name = $faker->person_formal_name;
2309              
2310             # "Miss Josephine Forest Beier DDS"
2311              
2312             # $person_formal_name = $faker->person_formal_name;
2313              
2314             # "Duncan Mann"
2315              
2316             =back
2317              
2318             =cut
2319              
2320             =head2 person_gender
2321              
2322             person_gender(HashRef $data) (Str)
2323              
2324             The person_gender method returns a random person gender.
2325              
2326             I>
2327              
2328             =over 4
2329              
2330             =item person_gender example 1
2331              
2332             package main;
2333              
2334             use Faker;
2335              
2336             my $faker = Faker->new('en-us');
2337              
2338             # my $person_gender = $faker->person_gender;
2339              
2340             # "male"
2341              
2342             # $person_gender = $faker->person_gender;
2343              
2344             # "male"
2345              
2346             # $person_gender = $faker->person_gender;
2347              
2348             # "female"
2349              
2350             =back
2351              
2352             =cut
2353              
2354             =head2 person_last_name
2355              
2356             person_last_name(HashRef $data) (Str)
2357              
2358             The person_last_name method returns a random person last name.
2359              
2360             I>
2361              
2362             =over 4
2363              
2364             =item person_last_name example 1
2365              
2366             package main;
2367              
2368             use Faker;
2369              
2370             my $faker = Faker->new('en-us');
2371              
2372             # my $person_last_name = $faker->person_last_name;
2373              
2374             # "Heaney"
2375              
2376             # $person_last_name = $faker->person_last_name;
2377              
2378             # "Johnston"
2379              
2380             # $person_last_name = $faker->person_last_name;
2381              
2382             # "Steuber"
2383              
2384             =back
2385              
2386             =cut
2387              
2388             =head2 person_name
2389              
2390             person_name(HashRef $data) (Str)
2391              
2392             The person_name method returns a random person name.
2393              
2394             I>
2395              
2396             =over 4
2397              
2398             =item person_name example 1
2399              
2400             package main;
2401              
2402             use Faker;
2403              
2404             my $faker = Faker->new('en-us');
2405              
2406             # my $person_name = $faker->person_name;
2407              
2408             # "Russel Krajcik"
2409              
2410             # $person_name = $faker->person_name;
2411              
2412             # "Alayna Josephine Kunde"
2413              
2414             # $person_name = $faker->person_name;
2415              
2416             # "Viviane Fritsch"
2417              
2418             =back
2419              
2420             =cut
2421              
2422             =head2 person_name_prefix
2423              
2424             person_name_prefix(HashRef $data) (Str)
2425              
2426             The person_name_prefix method returns a random person name prefix.
2427              
2428             I>
2429              
2430             =over 4
2431              
2432             =item person_name_prefix example 1
2433              
2434             package main;
2435              
2436             use Faker;
2437              
2438             my $faker = Faker->new('en-us');
2439              
2440             # my $person_name_prefix = $faker->person_name_prefix;
2441              
2442             # "Mr."
2443              
2444             # $person_name_prefix = $faker->person_name_prefix;
2445              
2446             # "Mr."
2447              
2448             # $person_name_prefix = $faker->person_name_prefix;
2449              
2450             # "Sir"
2451              
2452             =back
2453              
2454             =cut
2455              
2456             =head2 person_name_suffix
2457              
2458             person_name_suffix(HashRef $data) (Str)
2459              
2460             The person_name_suffix method returns a random person name suffix.
2461              
2462             I>
2463              
2464             =over 4
2465              
2466             =item person_name_suffix example 1
2467              
2468             package main;
2469              
2470             use Faker;
2471              
2472             my $faker = Faker->new('en-us');
2473              
2474             # my $person_name_suffix = $faker->person_name_suffix;
2475              
2476             # "I"
2477              
2478             # $person_name_suffix = $faker->person_name_suffix;
2479              
2480             # "I"
2481              
2482             # $person_name_suffix = $faker->person_name_suffix;
2483              
2484             # "II"
2485              
2486             =back
2487              
2488             =cut
2489              
2490             =head2 software_author
2491              
2492             software_author(HashRef $data) (Str)
2493              
2494             The software_author method returns a random software author.
2495              
2496             I>
2497              
2498             =over 4
2499              
2500             =item software_author example 1
2501              
2502             package main;
2503              
2504             use Faker;
2505              
2506             my $faker = Faker->new('en-us');
2507              
2508             # my $software_author = $faker->software_author;
2509              
2510             # "Jamison Skiles"
2511              
2512             # $software_author = $faker->software_author;
2513              
2514             # "Josephine Kunde"
2515              
2516             # $software_author = $faker->software_author;
2517              
2518             # "Darby Boyer"
2519              
2520             =back
2521              
2522             =cut
2523              
2524             =head2 software_name
2525              
2526             software_name(HashRef $data) (Str)
2527              
2528             The software_name method returns a random software name.
2529              
2530             I>
2531              
2532             =over 4
2533              
2534             =item software_name example 1
2535              
2536             package main;
2537              
2538             use Faker;
2539              
2540             my $faker = Faker->new('en-us');
2541              
2542             # my $software_name = $faker->software_name;
2543              
2544             # "Job"
2545              
2546             # $software_name = $faker->software_name;
2547              
2548             # "Zamit"
2549              
2550             # $software_name = $faker->software_name;
2551              
2552             # "Stronghold"
2553              
2554             =back
2555              
2556             =cut
2557              
2558             =head2 software_semver
2559              
2560             software_semver(HashRef $data) (Str)
2561              
2562             The software_semver method returns a random software semver.
2563              
2564             I>
2565              
2566             =over 4
2567              
2568             =item software_semver example 1
2569              
2570             package main;
2571              
2572             use Faker;
2573              
2574             my $faker = Faker->new('en-us');
2575              
2576             # my $software_semver = $faker->software_semver;
2577              
2578             # "1.4.0"
2579              
2580             # $software_semver = $faker->software_semver;
2581              
2582             # "4.6.8"
2583              
2584             # $software_semver = $faker->software_semver;
2585              
2586             # "5.0.7"
2587              
2588             =back
2589              
2590             =cut
2591              
2592             =head2 software_version
2593              
2594             software_version(HashRef $data) (Str)
2595              
2596             The software_version method returns a random software version.
2597              
2598             I>
2599              
2600             =over 4
2601              
2602             =item software_version example 1
2603              
2604             package main;
2605              
2606             use Faker;
2607              
2608             my $faker = Faker->new('en-us');
2609              
2610             # my $software_version = $faker->software_version;
2611              
2612             # 1.4
2613              
2614             # $software_version = $faker->software_version;
2615              
2616             # "0.4.4"
2617              
2618             # $software_version = $faker->software_version;
2619              
2620             # "0.4.5"
2621              
2622             =back
2623              
2624             =cut
2625              
2626             =head2 telephone_number
2627              
2628             telephone_number(HashRef $data) (Str)
2629              
2630             The telephone_number method returns a random telephone number.
2631              
2632             I>
2633              
2634             =over 4
2635              
2636             =item telephone_number example 1
2637              
2638             package main;
2639              
2640             use Faker;
2641              
2642             my $faker = Faker->new('en-us');
2643              
2644             # my $telephone_number = $faker->telephone_number;
2645              
2646             # "01408446845"
2647              
2648             # $telephone_number = $faker->telephone_number;
2649              
2650             # "769-454-4390"
2651              
2652             # $telephone_number = $faker->telephone_number;
2653              
2654             # "1-822-037-0225x82882"
2655              
2656             =back
2657              
2658             =cut
2659              
2660             =head2 user_login
2661              
2662             user_login(HashRef $data) (Str)
2663              
2664             The user_login method returns a random user login.
2665              
2666             I>
2667              
2668             =over 4
2669              
2670             =item user_login example 1
2671              
2672             package main;
2673              
2674             use Faker;
2675              
2676             my $faker = Faker->new('en-us');
2677              
2678             # my $user_login = $faker->user_login;
2679              
2680             # "Russel44"
2681              
2682             # $user_login = $faker->user_login;
2683              
2684             # "aMayer7694"
2685              
2686             # $user_login = $faker->user_login;
2687              
2688             # "Amalia89"
2689              
2690             =back
2691              
2692             =cut
2693              
2694             =head2 user_password
2695              
2696             user_password(HashRef $data) (Str)
2697              
2698             The user_password method returns a random user password.
2699              
2700             I>
2701              
2702             =over 4
2703              
2704             =item user_password example 1
2705              
2706             package main;
2707              
2708             use Faker;
2709              
2710             my $faker = Faker->new('en-us');
2711              
2712             # my $user_password = $faker->user_password;
2713              
2714             # "48R+a}[Lb?&0725"
2715              
2716             # $user_password = $faker->user_password;
2717              
2718             # ",0w\$h4155>*0M"
2719              
2720             # $user_password = $faker->user_password;
2721              
2722             # ")P2^'q695a}8GX"
2723              
2724             =back
2725              
2726             =cut
2727              
2728             =head1 FEATURES
2729              
2730             This package provides the following features:
2731              
2732             =cut
2733              
2734             =over 4
2735              
2736             =item plugins-feature
2737              
2738             This package loads and dispatches calls to plugins (the fake data generators)
2739             which allow for extending the library in environment-specific ways.
2740              
2741             B
2742              
2743             package Faker::Plugin::HttpContentType;
2744              
2745             use base 'Faker::Plugin';
2746              
2747             sub execute {
2748             'video/mpeg'
2749             }
2750              
2751             package main;
2752              
2753             use Faker;
2754              
2755             my $faker = Faker->new;
2756              
2757             my $http_content_type = $faker->http_content_type;
2758              
2759             # "video/mpeg"
2760              
2761             B
2762              
2763             package Faker::Plugin::HttpContentType;
2764              
2765             use base 'Faker::Plugin';
2766              
2767             sub execute {
2768             'video/mpeg'
2769             }
2770              
2771             package main;
2772              
2773             my $plugin = Faker::Plugin::HttpContentType->new;
2774              
2775             my $http_content_type = $plugin->execute;
2776              
2777             # "video/mpeg"
2778              
2779             =back
2780              
2781             =over 4
2782              
2783             =item locales-feature
2784              
2785             This package can be configured to return localized fake data, typically
2786             organized under namespaces specific to the locale specified.
2787              
2788             B
2789              
2790             package Faker::Plugin::Dothraki::RandomPhrase;
2791              
2792             use base 'Faker::Plugin';
2793              
2794             sub execute {
2795             'Hash yer dothrae chek asshekh?'
2796             }
2797              
2798             package main;
2799              
2800             use Faker;
2801              
2802             my $faker = Faker->new('dothraki');
2803              
2804             my $random_phrase = $faker->random_phrase;
2805              
2806             # "Hash yer dothrae chek asshekh?"
2807              
2808             B
2809              
2810             package Faker::Plugin::Klingon::RandomPhrase;
2811              
2812             use base 'Faker::Plugin';
2813              
2814             sub execute {
2815             'nuqDaq ’oH puchpa’’e’'
2816             }
2817              
2818             package main;
2819              
2820             use Faker;
2821              
2822             my $faker = Faker->new('klingon');
2823              
2824             my $random_phrase = $faker->random_phrase;
2825              
2826             # "nuqDaq ’oH puchpa’’e’"
2827              
2828             B
2829              
2830             package Faker::Plugin::Dothraki::RandomPhrase;
2831              
2832             use base 'Faker::Plugin';
2833              
2834             sub execute {
2835             'Hash yer dothrae chek asshekh?'
2836             }
2837              
2838             package Faker::Plugin::Klingon::RandomPhrase;
2839              
2840             use base 'Faker::Plugin';
2841              
2842             sub execute {
2843             'nuqDaq ’oH puchpa’’e’'
2844             }
2845              
2846             package main;
2847              
2848             use Faker;
2849              
2850             my $faker = Faker->new(['dothraki', 'klingon']);
2851              
2852             my $random_phrase = $faker->random_phrase;
2853              
2854             # "nuqDaq ’oH puchpa’’e’"
2855              
2856             # $random_phrase = $faker->random_phrase;
2857              
2858             # "Hash yer dothrae chek asshekh?"
2859              
2860             # $random_phrase = $faker->random_phrase;
2861              
2862             # "nuqDaq ’oH puchpa’’e’"
2863              
2864             # $random_phrase = $faker->random_phrase;
2865              
2866             # "nuqDaq ’oH puchpa’’e’"
2867              
2868             =back
2869              
2870             =over 4
2871              
2872             =item caching-feature
2873              
2874             Often one generator's fake data is composed of the output from other
2875             generators. Caching can be used to make generators faster, and to make fake
2876             data more realistic.
2877              
2878             B
2879              
2880             package main;
2881              
2882             use Faker;
2883              
2884             my $faker = Faker->new('en-us');
2885              
2886             my $person_first_name = $faker->person_first_name;
2887              
2888             # "Jordi"
2889              
2890             my $person_last_name = $faker->person_last_name;
2891              
2892             # "Smitham"
2893              
2894             my $internet_email_address = $faker->internet_email_address;
2895              
2896             # "deshaun8768@hotmail.com"
2897              
2898             $person_first_name = $faker->cache('person_first_name');
2899              
2900             # "Arlene"
2901              
2902             $person_last_name = $faker->cache('person_last_name');
2903              
2904             # "Cassin"
2905              
2906             $internet_email_address = $faker->internet_email_address;
2907              
2908             # "arlene6025@proton.me"
2909              
2910             =back
2911              
2912             =head1 AUTHORS
2913              
2914             Awncorp, C
2915              
2916             =cut