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

#!/usr/bin/perl -w

package Dev::Bollocks;

use Math::String;
@ISA = qw(Math::String);

use vars qw($VERSION $accuracy $precision $fallback $rnd_mode);
$VERSION = 0.06;
require  5.008001;
use strict;

$accuracy = undef;
$precision = undef;
$fallback = 0;
$rnd_mode = 'even';

use overload
'cmp'   =>      sub { $_[2] ?
              $_[1] cmp Math::String::bstr($_[0]) :
              Math::String::bstr($_[0]) cmp $_[1] },
# can modify arg of ++ and --, so avoid a new-copy for speed
'++'    =>      sub { Math::BigInt::badd($_[0],Math::BigInt->bone()) },
'--'    =>      sub { Math::BigInt::badd($_[0],Math::BigInt->bone('-')) },

;

my $CALC;
my $bollocks;

BEGIN
  {
  $CALC = Math::BigInt->config()->{lib};

  # if we did this for every new() instead of in BEGIN, we would waste even
  # more resources. But we can't wait for management all day...
    my $verbs = [ qw/
	aggregate
	administrate
	accelerate
	architect
	benchmark
	brand
	build
	bully
	cluster
	create
	coordinate
	consolidate
	compete
	conquer
	customize
	cultivate
	deliver
	deploy
	develop
	disintermediate
	disseminate
	differentiate
	drive
	e-enable
	embrace
	empower
	enable
	engage
	engineer
	enhance
	entrench
	envisioneer
	establish
	evolve
	expedite
	exploit
	extend
	facilitate
	fashion
	foster
	generate
	grow
	harness
	harvest
	improve
	implement
	incentivize
	incubate
	industrialize
	innovate
	introduce
	integrate
	initiate
	iterate
	lead
	leverage
	network
	negotiate
	market
	maintain
	maximize
	mesh
	monetize
	morph
	optimize
	orchestrate
	participate
	pursue
	promote
	reintermediate
	reinvent
	repurpose
	restore
	revolutionize
	scale
	seize
	strategize
	streamline
	supply
	syndicate
	synergize
	synthesize
	target
	transform
	transition
	unleash
	utilize
	visualize
     /];
    my $adverbs = [ qw(
	adaptively
	authoritatively
	administratively
	advantageously
	ambassadorially
	apprehensively
	appropriately
	assertively
	augmentatively
	autoschediastically
	biannually
	carefully
	centrally
	challengingly
	collaboratively
	confidentially
	conveniently
	competently
	completely
	continuously
	continually
	dramatically
	dynamically
	enthusiastically
	evangelistically
	efficiently
	elementarily
	economically
	enormously
	greatly
	globally
	heterogeneously
	interactively
	paradigmatically
        preemptively
	proactively
	professionally
	quickly
	revolutionarily
	seamlessly
	simultaneously
	synergistically
	vitalistically
	widespreadedly
     )];
    my $adjectives = [ qw(
	24/365
	24/7
	advanced
	attention-grabbing
	B2B
	B2C
	back-end
	best-of-breed
	bleeding-edge
	bricks-and-clicks
	clicks-and-mortar
	collaborative
	compelling
	corporate
	cross-platform
	cross-media
	customized
	cutting-edge
	distributed
	dot-com
	dynamic
	efficient
	eye-catching
	eigth-generation
	error-free
	edge-of-your-seat
	end-to-end
	enterprise
	enterprise-class
	eligible
	exceptional
	extensible
	essential
	fourth-generation
	fifth-generation
	fine-grained
	frictionless
	front-end
	global
	granular
	guinine
	holistic
	high-yield
	high-end
	impactful
	innovative
	integrated
	interactive
	interdependent
	intuitive
	internet
	industry-wide
	killer
	leading-edge
	low-risk
	magnetic
	market-driven
	mission-critical
	next-generation
	network
	one-to-one
	open-source
	out-of-the-box
	plug-and-play
	performance-oriented
	principle-centered
	proactive
	professional
	prospective
	real-time
	revolutionary
	robust
	scalable
	seamless
	six-generation
	second-generation
	sexy
	slick
	sticky
	strategic
	synergistic
	third-generation
	transparent
	total
	turn-key
	ubiquitous
	unique
	user-centric
	value-added
	vertical
	viral
	virtual
	visionary
	web-enabled
	wireless
	world-class
     ) ];
    my $nouns = [ qw/
	action-items
	applications
	appliances
	architectures
	bandwidth
	channels
	communities
	content
	convergence
	customers
	data
	deliverables
	developments
	e-business
	e-commerce
	e-markets
	e-services
	e-tailers
	environments
	experiences
	eyeballs
	features
	functionalities
	infomediaries
	information
	infrastructures
	initiatives
	interfaces
	markets
	m-commerce
	CEOs
	IPOs
	clusters
	designs
	market-growth
	materials
	methodologies
	metrics
	meta-services
	mindshares
	models
	networks
	niches
	paradigms
	partnerships
	patterns
	platforms
	products
	portals
	relationships
	ROI
	synergies
	segments
	schemas
	services
	solutions
	supply-chains
	systems
	technologies
	users
	web-readiness
        design-patterns / ];

  my @cs;
  foreach ($nouns,$verbs,$adjectives,$adverbs)
    {
    $_ = [ sort @$_ ];
    push @cs, Math::String::Charset->new( { sep => ' ', start => $_ } );
#    $cs[-1]->dump(),"\n";
    }
  $bollocks =
    Math::String::Charset::Grouped->new( {
      # start => [ @$verbs, @$adjectives, @$nouns ],
      sets => {
       1  => $cs[3],	# adverbs
       2  => $cs[1],	# verbs
       0  => $cs[2], 	# adjectives
       -1 => $cs[0], 	# nouns
      },
      sep => ' ', } );
  die $bollocks->error() if $bollocks->error() ne "";;
  }

sub _set_charset
  {
  # store reference to charset object, or make one if given array/hash ref
  # first method should be prefered for speed/memory reasons
  my $self = shift;
  my $cs = shift;

  $cs = $bollocks if !defined $cs;		# default Bollocks charset
  $cs = Math::String::Charset->new( $cs ) if ref($cs) =~ /^(ARRAY|HASH)$/;
  die "charset '$cs' is not a reference" unless ref($cs);
  $self->{_set} = $cs;
  return $self;
  }

sub bzero
  {
  my @a = (@_,$bollocks); shift @a if @_ == 0;
  my $x = Math::String::bzero(@a); bless $x, __PACKAGE__;
  }

sub binf
  {
  my @a = (@_,$bollocks); shift @a if @_ == 0;
  my $x = Math::String::binf(@a); bless $x, __PACKAGE__;
  }

sub bnan
  {
  my @a = (@_,$bollocks); shift @a if @_ == 0;
  my $x = Math::String::bnan(@a); bless $x, __PACKAGE__;
  }

sub from_number
  {
  my $x = Math::String::from_number(@_,$bollocks); bless $x, __PACKAGE__;
  }

sub rand
  {
  # generate a random crap with 4 words
  my $self = shift;

  my $length = int(abs(shift || 4));

  my $x = Dev::Bollocks->new();
  my $len = $bollocks->class($length);
  my $rand = Math::BigInt->new(int(rand($len)));
  $len = $bollocks->class($length-1);
  $rand += $len;
  $x += $rand;
  $x;
  }

sub first
  {
  my $x = shift;

  return $x::SUPER->first(@_) if ref($x);	# $x->first();
  $x = shift if $x eq 'Dev::Bollocks';		# Dev::Bollocks->first(3);
  Math::String->first($x,$bollocks);		# Dev::Bollocks::first(3);
  }

sub last
  {
  my $x = shift;

  return $x::SUPER->last(@_) if ref($x);	# $x->first();
  $x = shift if $x eq 'Dev::Bollocks';		# Dev::Bollocks->last(3);
  Math::String->last($x,$bollocks);		# Dev::Bollocks::last(3);
  }

#############################################################################

=head1 NAME

Dev::Bollocks - Arbitrary sized bollocks straight from middle management

=head1 SYNOPSIS

    use Dev::Bollocks;

    print Dev::Bollocks->new(),"\n";	# create first bollox
    print Dev::Bollocks->rand(),"\n";	# create random bollox
    print Dev::Bollocks::rand(3),"\n";	# create random bollox w/ 3 words

    $x = Dev::Bollocks->rand(),"\n";	# create some random bollox
    for ($i = 0; $i ++; $i < 10)
      {
      print "$x\n"; $x++;		# next bollox
      }

=head1 REQUIRES

perl v5.8.1, L, L, L,
L

=head1 EXPORTS

Exports nothing.

=head1 DESCRIPTION

This module implements /dev/bollocks, which generates management bullshit
whenever you need it.

Of course, to follow the spirit outlined in
L
this module doesn't simple do a C, that would be too easy,
too fast and non-portable. And bullshit is universilly portable.

Thus the module makes a subclass of Math::String and changes the default
charset to a charset that somewhat emulates and extends the original
/dev/bollocks charset.

As a side-effect you can calculate with bollocks strings, or even compare them
to find out which is greater crap than the other:

	use Dev::Bollocks;

	my $x = Dev::Bollocks->rand();
	my $y = Dev::Bollocks->rand();

	print "$x is more crap than $y\n" if ($x > $y);
	print "$y is more crap than $x\n" if ($y > $x);
	print "$x is the same bollox than $y\n" unless ($y != $x);

=head1 EXAMPLES

Run examples/bollocks.pl to get something like:

 We were told to adaptively monetize holistic market-driven systems.
 It is important to appropriately fashion meta-services.
 We can enthusiastically utilize proactive channels.
 We should paradigmatically streamline e-services.
 Your job is to seamlessly architect dynamic out-of-the-box clusters.
 Our job is to interactively harness high-yield 24/7 markets.
 We were told to widespreadedly supply holistic synergies.
 So, let's assertively grow front-end vertical architectures.
 Your job is to completely exploit scalable meta-services.
 All of us plan to evangelistically empower low-risk edge-of-your-seat content.
 So, let's augmentatively build back-end systems.
 And next we simultaneously transform sexy m-commerce.
 All of us plan to continually benchmark world-class methodologies.
 Your job is to enormously disseminate open-source interactive mindshares.
 So, let's simultaneously transform interfaces.
 Our job is to confidentially coordinate intuitive intuitive e-commerce.
 It is important to paradigmatically embrace robust dot-com solutions.
 And next we appropriately innovate strategic customers.
 All of us plan to challengingly target synergies.
 Our job is to conveniently generate collaborative deliverables.
 It is important to evangelistically synergize high-yield robust IPOs.
 We should competently e-enable convergence.
 All of us plan to economically negotiate action-items.
 It is important to competently integrate value-added efficient users.
 We better widespreadedly promote vertical strategic materials.
 And next we centrally harness convergence.
 So, let's dynamically e-enable out-of-the-box 24/365 customers.
 And next we dramatically enhance efficient development.
 We better biannually enable high-yield metrics.

=head1 INTERNAL DETAILS

I spare you the internal details. You don't want to know the internas of
middle management. Trust me. If you still are inclined to know, see
L. Don't say I didn't warn you.

=head1 USEFULL METHODS

=head2 B

            $bollocks = Dev::Bollock->new();

Create a new Dev::Bollocks object with the first bollocks ever. Optionally you
can pass another bollocks string and it will see if it is valid middle
management speak. Never was generating crap so easy!

=head2 B

            $bollocks = Dev::Bollock->rand($words);

Create a new, random Dev::Bollocks object with $words words. C<$words> defaults
to 4.

=head2 B

            $bollocks->first($length);
            $bollocks = Dev::Bollocks->first($length);

Generate the first bollocks of a certain length, length beeing here the number
of words.

=head2 B

            $bollocks->last($length);
            $bollocks = Dev::Bollocks->last($length);

Same as L, only does the, well, last crap you expect.

=head2 B

            $bollocks->as_number();

Return internal number as normalized BigInt including sign.

=head2 B

            $bollocks->length();

Return the number of characters in the resulting string (aka it's length). It
returns the number of words, since a Dev::Bollocks charset contains the crap
words as 'characters'.

=head2 B

            $bollocks->charset();

Return a reference to the charset of the Dev::Bollocks object.

=head1 PERFORMANCE

It is rather slow. This is a feature, not a bug.

=head2 Benchmarks

Were not done on purpose. Nobody expects middle, or any other, for what it
matters, management, to be fast or efficient, so we didn't waste our time in
profiling it.

=head1 PLANS

Bring upper and lower management speak to the, er, waiting masses.

=head1 LICENSE

This program is free crap; you may redistribute it and/or modify it under
the same terms as Perl itself.

=head1 CREDITS

=over 2

=item *

The original idea is from
L.

=item *

I also found some words by searching the web for "Vision" statements
(L is your friend!).

=item *

Webster's dictionary. Nowhere you can find gems like autoschediastically,
daffydowndilly or histomorphologically.

=item *

And then there is
L.

=item *

From L:

I<"This time, AMD attempts to entrench its position in the
performance-oriented high-end segment."> - You just can't make that stuff
up.

=item *

L:

...provide enterprise-class UNIX operating environments...
...matched the unique scaleable, mission-critical features...

=item *

The journal I provided lot's of, uh, well, genuine
[mental note to self: add genuine to the list of adjectives] material:

=over 3

=item An VESA ad

I<"...to foster industry innovation and global market growth">

=item Some headline

I<"organic success stimulates industry-wide bandwagon">

=back

Yeah, whatever.

=back

=head1 AUTHOR

If you use this module in one of your projects (haha!), then please email me.
Or maybe better not. Oh, crap, mail me anyway.

(c) Tels http://bloodgate.com 2001 - 2006.

=cut

1;