File Coverage

blib/lib/Dev/Bollocks.pm
Criterion Covered Total %
statement 1 3 33.3
branch n/a
condition n/a
subroutine 1 1 100.0
pod n/a
total 2 4 50.0


line stmt bran cond sub pod time code
1             #!/usr/bin/perl -w
2              
3             package Dev::Bollocks;
4              
5 1     1   42343 use Math::String;
  0            
  0            
6             @ISA = qw(Math::String);
7              
8             use vars qw($VERSION $accuracy $precision $fallback $rnd_mode);
9             $VERSION = 0.06;
10             require 5.008001;
11             use strict;
12              
13             $accuracy = undef;
14             $precision = undef;
15             $fallback = 0;
16             $rnd_mode = 'even';
17              
18             use overload
19             'cmp' => sub { $_[2] ?
20             $_[1] cmp Math::String::bstr($_[0]) :
21             Math::String::bstr($_[0]) cmp $_[1] },
22             # can modify arg of ++ and --, so avoid a new-copy for speed
23             '++' => sub { Math::BigInt::badd($_[0],Math::BigInt->bone()) },
24             '--' => sub { Math::BigInt::badd($_[0],Math::BigInt->bone('-')) },
25              
26             ;
27              
28             my $CALC;
29             my $bollocks;
30              
31             BEGIN
32             {
33             $CALC = Math::BigInt->config()->{lib};
34              
35             # if we did this for every new() instead of in BEGIN, we would waste even
36             # more resources. But we can't wait for management all day...
37             my $verbs = [ qw/
38             aggregate
39             administrate
40             accelerate
41             architect
42             benchmark
43             brand
44             build
45             bully
46             cluster
47             create
48             coordinate
49             consolidate
50             compete
51             conquer
52             customize
53             cultivate
54             deliver
55             deploy
56             develop
57             disintermediate
58             disseminate
59             differentiate
60             drive
61             e-enable
62             embrace
63             empower
64             enable
65             engage
66             engineer
67             enhance
68             entrench
69             envisioneer
70             establish
71             evolve
72             expedite
73             exploit
74             extend
75             facilitate
76             fashion
77             foster
78             generate
79             grow
80             harness
81             harvest
82             improve
83             implement
84             incentivize
85             incubate
86             industrialize
87             innovate
88             introduce
89             integrate
90             initiate
91             iterate
92             lead
93             leverage
94             network
95             negotiate
96             market
97             maintain
98             maximize
99             mesh
100             monetize
101             morph
102             optimize
103             orchestrate
104             participate
105             pursue
106             promote
107             reintermediate
108             reinvent
109             repurpose
110             restore
111             revolutionize
112             scale
113             seize
114             strategize
115             streamline
116             supply
117             syndicate
118             synergize
119             synthesize
120             target
121             transform
122             transition
123             unleash
124             utilize
125             visualize
126             /];
127             my $adverbs = [ qw(
128             adaptively
129             authoritatively
130             administratively
131             advantageously
132             ambassadorially
133             apprehensively
134             appropriately
135             assertively
136             augmentatively
137             autoschediastically
138             biannually
139             carefully
140             centrally
141             challengingly
142             collaboratively
143             confidentially
144             conveniently
145             competently
146             completely
147             continuously
148             continually
149             dramatically
150             dynamically
151             enthusiastically
152             evangelistically
153             efficiently
154             elementarily
155             economically
156             enormously
157             greatly
158             globally
159             heterogeneously
160             interactively
161             paradigmatically
162             preemptively
163             proactively
164             professionally
165             quickly
166             revolutionarily
167             seamlessly
168             simultaneously
169             synergistically
170             vitalistically
171             widespreadedly
172             )];
173             my $adjectives = [ qw(
174             24/365
175             24/7
176             advanced
177             attention-grabbing
178             B2B
179             B2C
180             back-end
181             best-of-breed
182             bleeding-edge
183             bricks-and-clicks
184             clicks-and-mortar
185             collaborative
186             compelling
187             corporate
188             cross-platform
189             cross-media
190             customized
191             cutting-edge
192             distributed
193             dot-com
194             dynamic
195             efficient
196             eye-catching
197             eigth-generation
198             error-free
199             edge-of-your-seat
200             end-to-end
201             enterprise
202             enterprise-class
203             eligible
204             exceptional
205             extensible
206             essential
207             fourth-generation
208             fifth-generation
209             fine-grained
210             frictionless
211             front-end
212             global
213             granular
214             guinine
215             holistic
216             high-yield
217             high-end
218             impactful
219             innovative
220             integrated
221             interactive
222             interdependent
223             intuitive
224             internet
225             industry-wide
226             killer
227             leading-edge
228             low-risk
229             magnetic
230             market-driven
231             mission-critical
232             next-generation
233             network
234             one-to-one
235             open-source
236             out-of-the-box
237             plug-and-play
238             performance-oriented
239             principle-centered
240             proactive
241             professional
242             prospective
243             real-time
244             revolutionary
245             robust
246             scalable
247             seamless
248             six-generation
249             second-generation
250             sexy
251             slick
252             sticky
253             strategic
254             synergistic
255             third-generation
256             transparent
257             total
258             turn-key
259             ubiquitous
260             unique
261             user-centric
262             value-added
263             vertical
264             viral
265             virtual
266             visionary
267             web-enabled
268             wireless
269             world-class
270             ) ];
271             my $nouns = [ qw/
272             action-items
273             applications
274             appliances
275             architectures
276             bandwidth
277             channels
278             communities
279             content
280             convergence
281             customers
282             data
283             deliverables
284             developments
285             e-business
286             e-commerce
287             e-markets
288             e-services
289             e-tailers
290             environments
291             experiences
292             eyeballs
293             features
294             functionalities
295             infomediaries
296             information
297             infrastructures
298             initiatives
299             interfaces
300             markets
301             m-commerce
302             CEOs
303             IPOs
304             clusters
305             designs
306             market-growth
307             materials
308             methodologies
309             metrics
310             meta-services
311             mindshares
312             models
313             networks
314             niches
315             paradigms
316             partnerships
317             patterns
318             platforms
319             products
320             portals
321             relationships
322             ROI
323             synergies
324             segments
325             schemas
326             services
327             solutions
328             supply-chains
329             systems
330             technologies
331             users
332             web-readiness
333             design-patterns / ];
334              
335             my @cs;
336             foreach ($nouns,$verbs,$adjectives,$adverbs)
337             {
338             $_ = [ sort @$_ ];
339             push @cs, Math::String::Charset->new( { sep => ' ', start => $_ } );
340             # $cs[-1]->dump(),"\n";
341             }
342             $bollocks =
343             Math::String::Charset::Grouped->new( {
344             # start => [ @$verbs, @$adjectives, @$nouns ],
345             sets => {
346             1 => $cs[3], # adverbs
347             2 => $cs[1], # verbs
348             0 => $cs[2], # adjectives
349             -1 => $cs[0], # nouns
350             },
351             sep => ' ', } );
352             die $bollocks->error() if $bollocks->error() ne "";;
353             }
354              
355             sub _set_charset
356             {
357             # store reference to charset object, or make one if given array/hash ref
358             # first method should be prefered for speed/memory reasons
359             my $self = shift;
360             my $cs = shift;
361              
362             $cs = $bollocks if !defined $cs; # default Bollocks charset
363             $cs = Math::String::Charset->new( $cs ) if ref($cs) =~ /^(ARRAY|HASH)$/;
364             die "charset '$cs' is not a reference" unless ref($cs);
365             $self->{_set} = $cs;
366             return $self;
367             }
368              
369             sub bzero
370             {
371             my @a = (@_,$bollocks); shift @a if @_ == 0;
372             my $x = Math::String::bzero(@a); bless $x, __PACKAGE__;
373             }
374              
375             sub binf
376             {
377             my @a = (@_,$bollocks); shift @a if @_ == 0;
378             my $x = Math::String::binf(@a); bless $x, __PACKAGE__;
379             }
380              
381             sub bnan
382             {
383             my @a = (@_,$bollocks); shift @a if @_ == 0;
384             my $x = Math::String::bnan(@a); bless $x, __PACKAGE__;
385             }
386              
387             sub from_number
388             {
389             my $x = Math::String::from_number(@_,$bollocks); bless $x, __PACKAGE__;
390             }
391              
392             sub rand
393             {
394             # generate a random crap with 4 words
395             my $self = shift;
396              
397             my $length = int(abs(shift || 4));
398              
399             my $x = Dev::Bollocks->new();
400             my $len = $bollocks->class($length);
401             my $rand = Math::BigInt->new(int(rand($len)));
402             $len = $bollocks->class($length-1);
403             $rand += $len;
404             $x += $rand;
405             $x;
406             }
407              
408             sub first
409             {
410             my $x = shift;
411              
412             return $x::SUPER->first(@_) if ref($x); # $x->first();
413             $x = shift if $x eq 'Dev::Bollocks'; # Dev::Bollocks->first(3);
414             Math::String->first($x,$bollocks); # Dev::Bollocks::first(3);
415             }
416              
417             sub last
418             {
419             my $x = shift;
420              
421             return $x::SUPER->last(@_) if ref($x); # $x->first();
422             $x = shift if $x eq 'Dev::Bollocks'; # Dev::Bollocks->last(3);
423             Math::String->last($x,$bollocks); # Dev::Bollocks::last(3);
424             }
425              
426             #############################################################################
427              
428             =head1 NAME
429              
430             Dev::Bollocks - Arbitrary sized bollocks straight from middle management
431              
432             =head1 SYNOPSIS
433              
434             use Dev::Bollocks;
435              
436             print Dev::Bollocks->new(),"\n"; # create first bollox
437             print Dev::Bollocks->rand(),"\n"; # create random bollox
438             print Dev::Bollocks::rand(3),"\n"; # create random bollox w/ 3 words
439              
440             $x = Dev::Bollocks->rand(),"\n"; # create some random bollox
441             for ($i = 0; $i ++; $i < 10)
442             {
443             print "$x\n"; $x++; # next bollox
444             }
445              
446             =head1 REQUIRES
447              
448             perl v5.8.1, L, L, L,
449             L
450              
451             =head1 EXPORTS
452              
453             Exports nothing.
454              
455             =head1 DESCRIPTION
456              
457             This module implements /dev/bollocks, which generates management bullshit
458             whenever you need it.
459              
460             Of course, to follow the spirit outlined in
461             L
462             this module doesn't simple do a C, that would be too easy,
463             too fast and non-portable. And bullshit is universilly portable.
464              
465             Thus the module makes a subclass of Math::String and changes the default
466             charset to a charset that somewhat emulates and extends the original
467             /dev/bollocks charset.
468              
469             As a side-effect you can calculate with bollocks strings, or even compare them
470             to find out which is greater crap than the other:
471              
472             use Dev::Bollocks;
473              
474             my $x = Dev::Bollocks->rand();
475             my $y = Dev::Bollocks->rand();
476              
477             print "$x is more crap than $y\n" if ($x > $y);
478             print "$y is more crap than $x\n" if ($y > $x);
479             print "$x is the same bollox than $y\n" unless ($y != $x);
480              
481             =head1 EXAMPLES
482              
483             Run examples/bollocks.pl to get something like:
484              
485             We were told to adaptively monetize holistic market-driven systems.
486             It is important to appropriately fashion meta-services.
487             We can enthusiastically utilize proactive channels.
488             We should paradigmatically streamline e-services.
489             Your job is to seamlessly architect dynamic out-of-the-box clusters.
490             Our job is to interactively harness high-yield 24/7 markets.
491             We were told to widespreadedly supply holistic synergies.
492             So, let's assertively grow front-end vertical architectures.
493             Your job is to completely exploit scalable meta-services.
494             All of us plan to evangelistically empower low-risk edge-of-your-seat content.
495             So, let's augmentatively build back-end systems.
496             And next we simultaneously transform sexy m-commerce.
497             All of us plan to continually benchmark world-class methodologies.
498             Your job is to enormously disseminate open-source interactive mindshares.
499             So, let's simultaneously transform interfaces.
500             Our job is to confidentially coordinate intuitive intuitive e-commerce.
501             It is important to paradigmatically embrace robust dot-com solutions.
502             And next we appropriately innovate strategic customers.
503             All of us plan to challengingly target synergies.
504             Our job is to conveniently generate collaborative deliverables.
505             It is important to evangelistically synergize high-yield robust IPOs.
506             We should competently e-enable convergence.
507             All of us plan to economically negotiate action-items.
508             It is important to competently integrate value-added efficient users.
509             We better widespreadedly promote vertical strategic materials.
510             And next we centrally harness convergence.
511             So, let's dynamically e-enable out-of-the-box 24/365 customers.
512             And next we dramatically enhance efficient development.
513             We better biannually enable high-yield metrics.
514              
515             =head1 INTERNAL DETAILS
516              
517             I spare you the internal details. You don't want to know the internas of
518             middle management. Trust me. If you still are inclined to know, see
519             L. Don't say I didn't warn you.
520              
521             =head1 USEFULL METHODS
522              
523             =head2 B
524              
525             $bollocks = Dev::Bollock->new();
526              
527             Create a new Dev::Bollocks object with the first bollocks ever. Optionally you
528             can pass another bollocks string and it will see if it is valid middle
529             management speak. Never was generating crap so easy!
530              
531             =head2 B
532              
533             $bollocks = Dev::Bollock->rand($words);
534              
535             Create a new, random Dev::Bollocks object with $words words. C<$words> defaults
536             to 4.
537              
538             =head2 B
539              
540             $bollocks->first($length);
541             $bollocks = Dev::Bollocks->first($length);
542              
543             Generate the first bollocks of a certain length, length beeing here the number
544             of words.
545              
546             =head2 B
547              
548             $bollocks->last($length);
549             $bollocks = Dev::Bollocks->last($length);
550              
551             Same as L, only does the, well, last crap you expect.
552              
553             =head2 B
554              
555             $bollocks->as_number();
556              
557             Return internal number as normalized BigInt including sign.
558              
559             =head2 B
560              
561             $bollocks->length();
562              
563             Return the number of characters in the resulting string (aka it's length). It
564             returns the number of words, since a Dev::Bollocks charset contains the crap
565             words as 'characters'.
566              
567             =head2 B
568              
569             $bollocks->charset();
570              
571             Return a reference to the charset of the Dev::Bollocks object.
572              
573             =head1 PERFORMANCE
574              
575             It is rather slow. This is a feature, not a bug.
576              
577             =head2 Benchmarks
578              
579             Were not done on purpose. Nobody expects middle, or any other, for what it
580             matters, management, to be fast or efficient, so we didn't waste our time in
581             profiling it.
582              
583             =head1 PLANS
584              
585             Bring upper and lower management speak to the, er, waiting masses.
586              
587             =head1 LICENSE
588              
589             This program is free crap; you may redistribute it and/or modify it under
590             the same terms as Perl itself.
591              
592             =head1 CREDITS
593              
594             =over 2
595              
596             =item *
597              
598             The original idea is from
599             L.
600              
601             =item *
602              
603             I also found some words by searching the web for "Vision" statements
604             (L is your friend!).
605              
606             =item *
607              
608             Webster's dictionary. Nowhere you can find gems like autoschediastically,
609             daffydowndilly or histomorphologically.
610              
611             =item *
612              
613             And then there is
614             L.
615              
616             =item *
617              
618             From L:
619              
620             I<"This time, AMD attempts to entrench its position in the
621             performance-oriented high-end segment."> - You just can't make that stuff
622             up.
623              
624             =item *
625              
626             L:
627              
628             ...provide enterprise-class UNIX operating environments...
629             ...matched the unique scaleable, mission-critical features...
630              
631             =item *
632              
633             The journal I provided lot's of, uh, well, genuine
634             [mental note to self: add genuine to the list of adjectives] material:
635              
636             =over 3
637              
638             =item An VESA ad
639              
640             I<"...to foster industry innovation and global market growth">
641              
642             =item Some headline
643              
644             I<"organic success stimulates industry-wide bandwagon">
645              
646             =back
647              
648             Yeah, whatever.
649              
650             =back
651              
652             =head1 AUTHOR
653              
654             If you use this module in one of your projects (haha!), then please email me.
655             Or maybe better not. Oh, crap, mail me anyway.
656              
657             (c) Tels http://bloodgate.com 2001 - 2006.
658              
659             =cut
660              
661             1;