Context::Singleton

• name: Branislav Zahradník
• pause id: BARNEY
• github: happy-barney
• email: happy.barney@gmail.com
• pm group: Brno.pm, Vienna.pm
• working at GoodData

Context::Singleton

• scoped singletons - similar to local
• immutability - name-value relation
• dependency injection
• logical programming flavor
• https://github.com/happy-barney/perl-Context-Singleton

Motivation

• refactoring
  • top-down processing
  • ~100 state variables (immutable once identified)
  • passed as parameters (positional, named, structures, objects)
• testing (via dependency injection)
  • don't build eg. Web::Request to prove request method workflow
• laziness
  • rules to build derived value
• evolving
  • rules and their dependencies are independent

Basic features

• narrow context (frame)

  frame { ... }

• populate value in current frame

  proclaim name => $value

• make value available in current frame (or die)

  my $var = deduce 'name'

• define recipe how to build value

  contrive name => (...)

frame

• default (root) frame
• create new context
• one definition per frame (proclaim, deduce)

frame {
	proclaim 'foo' => 1; # success
	frame {
		proclaim 'foo' => 2; # success
		proclaim 'foo' => 3; # failure
	};
};

proclaim

• define value in current frame
• dies if value already exists
• primary dependency injection tool

proclaim name => $value;

deduce

• fetch if available in current frame
• build in most common frame (where dependencies are available)
• dies if doesn't exist

frame { # depth 1
	proclaim 'foo' => 1;
	deduce 'foo'; # returns 1

	frame { # depth 2
		deduce 'foo+1'; # builds in depth 1 and returns 2
		proclaim 'foo' => 3; # fails
	};

	deduce 'foo+1'; # returns stored 2
};

contrive

• Recipe how to build value
• More than one recipe per value
• Circular dependencies allowed

Example: existing code

my $source_of_truth = Single::Source::Of::Truth->new (
	user_id => $user_id,
);
my $project_context = Project::Context->new (
	project_id => $project_id,
	user_id => $user_id,
	...
);
my $object_context => Object::Context->new(
	project_context => $project_context,
	object_id => $object_id,
	...
);

some_function (
	$request,
	$user_id,
	$source_of_truth,
	$project_context,
	$object_context,
);

Example: with Context::Singleton

proclaim request => $request;
proclaim user_id => $user_id,
proclaim project_id => $project_id;
proclaim object_id => $object_id;

some_function();

sub some_function {
	my $project_id = deduce 'project::id';
	...
}

Example: Net::GitHub::V3

contrive 'net::github' => (
	class => 'Net::GitHub::V3',
	dep => {
		login => 'github::login',
		password => 'github::password',
	},
);

contrive 'net::github::repository' => (
	dep => [ 'net::github', 'github::user', 'github::repository' ],
	as => sub {
		my ($connection, $user, $repository) = @_;

		my $repos = $connection->repos;
		$repos->set_default_user_repo( $user, $repository );
		$repos
	},
}

sub { ... ; my $gh = deduce 'net::github::repository'; ... }

Example: Net::GitHub::V3 (cont)

contrive 'net::github' => (
	class => 'Net::GitHub::V3',
	dep => { access_token => 'github::oauth_token' },
);

contrive 'github::user' => (
	dep => [ 'zuul::project' ], # user/repo
	as => { (split '/', $_[0])[0] }
);
contrive 'github::repository'' => (
	dep => [ 'zuul::project' ], # user/repo
	as => { (split '/', $_[0])[1] }
);

contrive 'github::login' => ( value => 'happy-barney');

Example: Circular dependencies

contrive 'single::source::of::truth' => (
	class => 'Single::Source::Of::Truth',
);

contrive 'project::id' => (
	deduce => 'project::info'
	builder => 'id',
);

contrive 'project::info' => (
	class => 'Project::Info',
	dep => [ 'project:struct' ],
);

contrive 'project::info' => (
	deduce => 'single::source::of::truth',
	builder => 'find_project',
	dep => [ 'project::id' ],
);

contrive 'project::struct' => (
	deduce => 'project::info',
	builder => 'as_struct',
);

Example: Dependency injection

Usage:

sub do_something_with_project {
	my $project_id = deduce 'project::id';
}

# will work with any of these line
proclaim 'project::struct' => value;
proclaim 'project::id' => value;
proclaim 'project::info' => value;

Testing:

proclaim 'Single::Source::Of::Truth' => 'Fiction';
proclaim 'single::source::of::truth' => Fiction->new;

Other features

• trigger

  trigger 'project::id' => sub {
  	Log::Log4perl::MDC->put( 'project_id' => $_[0] );
  };

• try_deduce

  deduce 'name'
  	if try_deduce 'name';

• is_deduced

  proclaim name => 'value'
  	unless is_deduced 'name';

Work in progress

• developer tools
• constraints support
• validity (no-downtime support)
  • valid_from / valid_to timestamp
  • valid_from / valid_to release
• bug hunting

Thanks

• you for not running away (yet)
• GoodData for motivation and support