Venus::Space

Space Class

Space Class for Perl 5

method: after method: all method: append method: around method: array method: arrays method: attributes method: authority method: basename method: before method: blessed method: build method: call method: chain method: child method: children method: cop method: data method: eval method: explain method: handle method: hash method: hashes method: hook method: id method: included method: inherits method: init method: inject method: integrates method: lfile method: load method: loaded method: locate method: meta method: mock method: name method: new method: parent method: parse method: parts method: patch method: patched method: pfile method: prepend method: purge method: rebase method: reload method: require method: root method: routine method: routines method: scalar method: scalars method: scrub method: sibling method: siblings method: splice method: swap method: tfile method: tryload method: unload method: unloaded method: unpatch method: use method: variables method: version method: visible

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/bar');

# $space->package; # Foo::Bar

This package provides methods for parsing and manipulating package namespaces.

Venus::Name

The after method installs a method modifier that executes after the original method, allowing you to perform actions after a method call. Note: The return value of the modifier routine is ignored; the wrapped method always returns the value from the original method. Modifiers are executed in the order they are stacked.

after(string $name, coderef $code) (coderef)

{ since => '4.15', }

=example-1 after

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/bar');

$space->do('init');

$space->routine('execute', sub {
  my ($self) = @_;
  return [@_];
});

my $after = $space->after('execute', sub {
  my ($self) = @_;
  $self->{executed} = 1;
});

# sub { ... }

The all method executes any available method on the instance and all instances representing packages inherited by the package represented by the invocant. This method supports dispatching, i.e. providing a method name and arguments whose return value will be acted on by this method.

all(string $method, any @args) (within[arrayref, tuple[string, any]])

{ since => '0.01', }

=example-1 all

package main;

use Venus::Space;

my $space = Venus::Space->new('Venus');

my $all = $space->all('id');

# [["Venus", "Venus"]]

The append method modifies the object by appending to the package namespace parts.

append(string @path) (Venus::Space)

{ since => '0.01', }

=example-1 append

# given: synopsis;

my $append = $space->append('baz');

# bless({ value => "Foo/Bar/Baz" }, "Venus::Space")

The around method installs a method modifier that wraps around the original method. The callback provided will recieve the original routine as its first argument. This method will raise an exception if the source routine does not exist. Modifiers are executed in the order they are stacked.

around(string $name, coderef $code) (coderef)

{ since => '4.15', }

=example-1 around

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/bar');

$space->do('init');

$space->routine('execute', sub {
  my ($self, $value) = @_;
  return [$value];
});

my $around = $space->around('execute', sub {
  my ($orig, $self, $value) = @_;
  my $result = $self->$orig($value);
  push @$result, 'wrapped';
  return $result;
});

# sub { ... }

The array method gets or sets the value for the given package array variable name.

array(string $name, any @data) (arrayref)

{ since => '0.01', }

=example-1 array

# given: synopsis;

package Foo::Bar;

our @handler = 'start';

package main;

my $array = $space->array('handler');

# ["start"]

The arrays method searches the package namespace for arrays and returns their names.

arrays() (arrayref)

{ since => '0.01', }

=example-1 arrays

# given: synopsis;

package Foo::Bar;

our @handler = 'start';
our @initial = ('next', 'prev');

package main;

my $arrays = $space->arrays;

# ["handler", "initial"]

The attributes method searches the package namespace for attributes and returns their names. This will not include attributes from roles, mixins, or superclasses.

attributes() (arrayref)

{ since => '1.02', }

=example-1 attributes

package Foo::Attrs;

use Venus::Class 'attr';

attr 'start';
attr 'abort';

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/attrs');

my $attributes = $space->attributes;

# ["start", "abort"]

The authority method returns the AUTHORITY declared on the target package, if any.

authority() (maybe[string])

{ since => '0.01', }

=example-1 authority

package Foo::Boo;

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/boo');

my $authority = $space->authority;

# undef

The basename method returns the last segment of the package namespace parts.

basename() (string)

{ since => '0.01', }

=example-1 basename

# given: synopsis;

my $basename = $space->basename;

# "Bar"

The before method installs a method modifier that executes before the original method, allowing you to perform actions before a method call. Note: The return value of the modifier routine is ignored; the wrapped method always returns the value from the original method. Modifiers are executed in the order they are stacked.

before(string $name, coderef $code) (coderef)

{ since => '4.15', }

=example-1 before

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/bar');

$space->do('init');

$space->routine('execute', sub {
  my ($self) = @_;
  return [@_];
});

my $before = $space->before('execute', sub {
  my ($self) = @_;
  $self->{started} = 1;
});

# sub { ... }

The blessed method blesses the given value into the package namespace and returns an object. If no value is given, an empty hashref is used.

blessed(Ref $data) (Venus::Space)

{ since => '0.01', }

=example-1 blessed

# given: synopsis;

package Foo::Bar;

sub import;

package main;

my $blessed = $space->blessed;

# bless({}, "Foo::Bar")

The build method attempts to call new on the package namespace and if successful returns the resulting object.

build(any @args) (Venus::Space)

{ since => '0.01', }

=example-1 build

# given: synopsis;

package Foo::Bar::Baz;

sub new {
  bless {}, $_[0];
}

package main;

my $build = $space->child('baz')->build;

# bless({}, "Foo::Bar::Baz")

The call method attempts to call the given subroutine on the package namespace and if successful returns the resulting value.

call(any @args) (any)

{ since => '0.01', }

=example-1 call

package Foo;

sub import;

sub start {
  'started'
}

package main;

use Venus::Space;

my $space = Venus::Space->new('foo');

my $result = $space->call('start');

# "started"

The chain method chains one or more method calls and returns the result.

chain(string | tuple[string, any] @steps) (any)

{ since => '0.01', }

=example-1 chain

package Chu::Chu0;

sub import;

package main;

use Venus::Space;

my $space = Venus::Space->new('Chu::Chu0');

my $result = $space->chain('blessed');

# bless({}, "Chu::Chu0")

The child method returns a new Venus::Space object for the child package namespace.

child(string @path) (Venus::Space)

{ since => '0.01', }

=example-1 child

# given: synopsis;

my $child = $space->child('baz');

# bless({ value => "Foo/Bar/Baz" }, "Venus::Space")

The children method searches %INC and @INC and retuns a list of Venus::Space objects for each child namespace found (one level deep).

children() (within[arrayref, object])

{ since => '0.01', }

=example-1 children

package main;

use Venus::Space;

my $space = Venus::Space->new('c_p_a_n');

my $children = $space->children;

# [
#   bless({ value => "CPAN/Author" }, "Venus::Space"),
#   bless({ value => "CPAN/Bundle" }, "Venus::Space"),
#   bless({ value => "CPAN/CacheMgr" }, "Venus::Space"),
#   ...
# ]

The cop method attempts to curry the given subroutine on the package namespace and if successful returns a closure. This method supports dispatching, i.e. providing a method name and arguments whose return value will be acted on by this method.

cop(string $method, any @args) (coderef)

{ since => '0.01', }

=example-1 cop

package Foo::Bar;

sub import;

sub handler {
  [@_]
}

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/bar');

my $code = $space->cop('handler', $space->blessed);

# sub { Foo::Bar::handler(..., @_) }

The data method attempts to read and return any content stored in the DATA section of the package namespace.

data() (string)

{ since => '0.01', }

=example-1 data

# given: synopsis;

my $data = $space->data;

# ""

The eval method takes a list of strings and evaluates them under the namespace represented by the instance.

eval(string @data) (any)

{ since => '0.01', }

=example-1 eval

package main;

use Venus::Space;

my $space = Venus::Space->new('foo');

my $eval = $space->eval('our $VERSION = 0.01');

# 0.01

The explain method returns the package name and is used in stringification operations.

explain() (string)

{ since => '0.01', }

=example-1 explain

# given: synopsis;

my $explain = $space->explain;

# "Foo::Bar"

The handle method installs a method modifier that wraps a method similar to around, providing low-level control over method execution. The modifier receives the original method as its first argument (which may be undef if the method doesn't exist), followed by the method's arguments. This is the foundation for the other method modifiers ("before", "after", "around"). The modifiers are executed in the order they are stacked rather than maintaining a global registry.

handle(string $name, coderef $code) (coderef)

{ since => '4.15', }

=example-1 handle

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/bar');

$space->do('init');

$space->routine('execute', sub {
  my ($self, $value) = @_;
  return $value;
});

my $handle = $space->handle('execute', sub {
  my ($orig, $self, $value) = @_;
  return $orig ? $self->$orig($value * 2) : 0;
});

# sub { ... }

The hash method gets or sets the value for the given package hash variable name.

hash(string $name, any @data) (hashref)

{ since => '0.01', }

=example-1 hash

# given: synopsis;

package Foo::Bar;

our %settings = (
  active => 1
);

package main;

my $hash = $space->hash('settings');

# { active => 1 }

The hashes method searches the package namespace for hashes and returns their names.

hashes() (arrayref)

{ since => '0.01', }

=example-1 hashes

# given: synopsis;

package Foo::Bar;

our %defaults = (
  active => 0
);

our %settings = (
  active => 1
);

package main;

my $hashes = $space->hashes;

# ["defaults", "settings"]

The hook method is a specialized method modifier helper that applies a modifier (after, around, before, or handle) to a lifecycle hook method. It automatically uppercases the hook name, making it convenient for modifying Venus lifecycle hooks like BUILD, BLESS, BUILDARGS, and AUDIT.

hook(string $type, string $name, coderef $code) (coderef)

{ since => '4.15', }

=example-1 hook

package Foo::Bar::Hook;

use Venus::Class;

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/bar/hook');

$space->routine('BUILD', sub {
  my ($self, $args) = @_;
  $self->{started} = 1;
});

my $hook = $space->hook('before', 'build', sub {
  my ($self) = @_;
  $self->{initialized} = 1;
});

# sub { ... }

The id method returns the fully-qualified package name as a label.

id() (string)

{ since => '0.01', }

=example-1 id

# given: synopsis;

my $id = $space->id;

# "Foo_Bar"

The lfile method returns a .pm file path for the underlying package.

lfile() (string)

{ since => '1.30', }

=example-1 lfile

# given: synopsis

package main;

my $lfile = $space->lfile;

# "Foo/Bar.pm"

The init method ensures that the package namespace is loaded and, whether created in-memory or on-disk, is flagged as being loaded and loadable.

init() (string)

{ since => '0.01', }

=example-1 init

package main;

use Venus::Space;

my $space = Venus::Space->new('kit');

my $init = $space->init;

# "Kit"

The inherits method returns the list of superclasses the target package is derived from.

inherits() (arrayref)

{ since => '0.01', }

=example-1 inherits

package Bar;

package main;

use Venus::Space;

my $space = Venus::Space->new('bar');

my $inherits = $space->inherits;

# []

The included method returns the path of the namespace if it exists in %INC.

included() (string | undef)

{ since => '0.01', }

=example-1 included

package main;

use Venus::Space;

my $space = Venus::Space->new('Venus/Space');

my $included = $space->included;

# "/path/to/lib/Venus/Space.pm"

The inject method monkey-patches the package namespace, installing a named subroutine into the package which can then be called normally, returning the fully-qualified subroutine name.

inject(string $name, maybe[coderef] $coderef) (any)

{ since => '0.01', }

=example-1 inject

package main;

use Venus::Space;

my $space = Venus::Space->new('kit');

my $inject = $space->inject('build', sub { 'finished' });

# *Kit::build

The integrates method returns the list of roles integrated into the target package.

integrates() (arrayref)

{ since => '1.30', }

=example-1 integrates

# given: synopsis

package main;

my $integrates = $space->integrates;

# []

The load method checks whether the package namespace is already loaded and if not attempts to load the package. If the package is not loaded and is not loadable, this method will throw an exception using confess. If the package is loadable, this method returns truthy with the package name. As a workaround for packages that only exist in-memory, if the package contains a new, with, meta, or import routine it will be recognized as having been loaded.

load() (string)

{ since => '0.01', }

=example-1 load

package main;

use Venus::Space;

my $space = Venus::Space->new('c_p_a_n');

my $load = $space->load;

# "CPAN"

The loaded method checks whether the package namespace is already loaded and returns truthy or falsy.

loaded() (boolean)

{ since => '0.01', }

=example-1 loaded

package main;

use Venus::Space;

my $space = Venus::Space->new('Kit');

$space->init;

$space->unload;

my $loaded = $space->loaded;

# 0

The locate method checks whether the package namespace is available in @INC, i.e. on disk. This method returns the file if found or an empty string.

locate() (string)

{ since => '0.01', }

=example-1 locate

package main;

use Venus::Space;

my $space = Venus::Space->new('xyz');

my $locate = $space->locate;

# ""

The meta method returns a Venus::Meta object representing the underlying package namespace. To access the meta object for the instance itself, use the superclass' "META" in Venus::Core method.

meta() (Venus::Meta)

{ since => '1.02', }

=example-1 meta

# given: synopsis

package main;

my $meta = $space->meta;

# bless({'name' => 'Foo::Bar'}, 'Venus::Meta')

The mock method returns a Venus::Space object representing an anonymous package that derives from the invoking package.

mock() (Venus::Space)

{ since => '1.50', }

=example-1 mock

# given: synopsis

package main;

my $mock = $space->mock;

# bless({'name' => 'Venus::Space::Mock::0001::Foo::Bar'}, 'Venus::Space')

# $mock->isa('Foo::Bar') # true

The name method returns the fully-qualified package name.

name() (string)

{ since => '0.01', }

=example-1 name

# given: synopsis;

my $name = $space->name;

# "Foo::Bar"

The new method constructs an instance of the package.

new(any @args) (Venus::Space)

{ since => '4.15', }

The parent method returns a new Venus::Space object for the parent package namespace.

parent() (Venus::Space)

{ since => '0.01', }

=example-1 parent

# given: synopsis;

my $parent = $space->parent;

# bless({ value => "Foo" }, "Venus::Space")

The parse method parses the string argument and returns an arrayref of package namespace segments (parts).

parse() (arrayref)

{ since => '0.01', }

=example-1 parse

# given: synopsis;

my $parse = $space->parse;

# ["Foo", "Bar"]

The parts method returns an arrayref of package namespace segments (parts).

parts() (arrayref)

{ since => '0.01', }

=example-1 parts

package main;

use Venus::Space;

my $space = Venus::Space->new('Foo');

my $parts = $space->parts;

# ["Foo"]

The patch method overwrites the named subroutine in the underlying package using the "swap" operation, stashing the original subroutine reference to be reset later using "unpatch".

patch(string $name, coderef $code) (Venus::Space)

{ since => '0.01', }

The patched method confirms whether a subroutine in the underlying namespace has been patched using the "patch" operation. If no name is provided, this method will return true if any subroutines have been patched. If a name is provided, this method will return true only if the named subroutine has been patched, and otherwise returns false.

patched(string $name) (boolean)

{ since => '3.55', }

The pfile method returns a .pod file path for the underlying package.

pfile() (string)

{ since => '1.30', }

=example-1 pfile

# given: synopsis

package main;

my $pfile = $space->pfile;

# "Foo/Bar.pod"

The prepend method modifies the object by prepending to the package namespace parts.

prepend(string @path) (Venus::Space)

{ since => '0.01', }

=example-1 prepend

# given: synopsis;

my $prepend = $space->prepend('etc');

# bless({ value => "Etc/Foo/Bar" }, "Venus::Space")

The purge method purges a package space by expunging its symbol table and removing it from %INC. Warning: This method deletes symbol table entries entirely, which may cause issues with code that holds compiled references to package variables. For safer cleanup that preserves symbol table structure, see "scrub".

purge() (Venus::Space)

{ since => '1.02', }

=example-1 purge

package main;

use Venus::Space;

# Bar::Gen is generated with $VERSION as 0.01

my $space = Venus::Space->new('Bar/Gen');

$space->load;

my $purge = $space->purge;

# bless({ value => "Bar::Gen" }, "Venus::Space")

# Bar::Gen->VERSION was 0.01, now undef

# Symbol table is gone, $space->visible is 0

The rebase method returns an object by prepending the package namespace specified to the base of the current object's namespace.

rebase(string @path) (Venus::Space)

{ since => '0.01', }

=example-1 rebase

# given: synopsis;

my $rebase = $space->rebase('zoo');

# bless({ value => "Zoo/Bar" }, "Venus::Space")

The reload method attempts to delete and reload the package namespace using the "load" method. Note: Reloading is additive and will overwrite existing symbols but does not remove symbols.

reload() (string)

{ since => '0.01', }

=example-1 reload

package main;

use Venus::Space;

# Foo::Gen is generated with $VERSION as 0.01

my $space = Venus::Space->new('Foo/Gen');

my $reload = $space->reload;

# Foo::Gen
# Foo::Gen->VERSION is 0.01

The require method executes a require statement within the package namespace specified.

require(string $target) (any)

{ since => '0.01', }

=example-1 require

# given: synopsis;

my $require = $space->require('Venus');

# 1

The root method returns the root package namespace segments (parts). Sometimes separating the root from the parts helps identify how subsequent child objects were derived.

root() (string)

{ since => '0.01', }

=example-1 root

# given: synopsis;

my $root = $space->root;

# "Foo"

The routine method gets or sets the subroutine reference for the given subroutine name.

routine(string $name, coderef $code) (coderef)

{ since => '0.01', }

=example-1 routine

package Foo;

sub cont {
  [@_]
}

sub abort {
  [@_]
}

package main;

use Venus::Space;

my $space = Venus::Space->new('foo');

my $routine = $space->routine('cont');

# sub { ... }

The routines method searches the package namespace for routines and returns their names.

routines() (arrayref)

{ since => '0.01', }

=example-1 routines

package Foo::Subs;

sub start {
  1
}

sub abort {
  1
}

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/subs');

my $routines = $space->routines;

# ["abort", "start"]

The scalar method gets or sets the value for the given package scalar variable name.

scalar(string $name, any @data) (any)

{ since => '0.01', }

=example-1 scalar

# given: synopsis;

package Foo::Bar;

our $root = '/path/to/file';

package main;

my $scalar = $space->scalar('root');

# "/path/to/file"

The scalars method searches the package namespace for scalars and returns their names.

scalars() (arrayref)

{ since => '0.01', }

=example-1 scalars

# given: synopsis;

package Foo::Bar;

our $root = 'root';
our $base = 'path/to';
our $file = 'file';

package main;

my $scalars = $space->scalars;

# ["base", "file", "root"]

The scrub method cleans a package space by nullifying its typeglobs (setting them to undef) for all symbols except special variables and routines (like @ISA, DESTROY, etc.), and removes it from %INC. Unlike "purge", this method preserves the stash entries allowing compiled code holding references to remain valid. Unlike "unload", this method preserves special symbols needed for proper package operation. See also "purge" and "unload".

scrub() (Venus::Space)

{ since => '4.15', }

=example-1 scrub

package main;

use Venus::Space;

# Bar::Gen is generated with $VERSION as 0.01

my $space = Venus::Space->new('Bar/Gen');

$space->load;

my $scrub = $space->scrub;

# bless({ value => "Bar::Gen" }, "Venus::Space")

# Bar::Gen->VERSION was 0.01, now undef

# Symbol table persists, $space->visible is 1

The sibling method returns a new Venus::Space object for the sibling package namespace.

sibling(string $path) (Venus::Space)

{ since => '0.01', }

=example-1 sibling

# given: synopsis;

my $sibling = $space->sibling('baz');

# bless({ value => "Foo/Baz" }, "Venus::Space")

The siblings method searches %INC and @INC and retuns a list of Venus::Space objects for each sibling namespace found (one level deep).

siblings() (within[arrayref, object])

{ since => '0.01', }

=example-1 siblings

package main;

use Venus::Space;

my $space = Venus::Space->new('encode/m_i_m_e');

my $siblings = $space->siblings;

# [
#   bless({ value => "Encode/MIME/Header" }, "Venus::Space"),
#   bless({ value => "Encode/MIME/Name" }, "Venus::Space"),
#   ...
# ]

The splice method perform a Perl "splice" in perlfunc operation on the package namespace.

splice(number $offset, number $length, any @list) (Venus::Space)

{ since => '0.09', }

=example-1 splice

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/baz');

my $splice = $space->splice(1, 0, 'bar');

# bless({ value => "Foo/Bar/Baz" }, "Venus::Space")

The swap method overwrites the named subroutine in the underlying package with the code reference provided and returns the original subroutine as a code reference. The code provided will be passed a reference to the original subroutine as its first argument.

swap(string $name, coderef $code) (coderef)

{ since => '1.95', }

=example-1 swap

package Foo::Swap;

use Venus::Class;

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/swap');

my $subroutine = $space->swap('new', sub {
  my ($next, @args) = @_;
  my $self = $next->(@args);
  $self->{swapped} = 1;
  return $self;
});

# sub { ... }

The tfile method returns a .t file path for the underlying package.

tfile() (string)

{ since => '1.30', }

=example-1 tfile

# given: synopsis

package main;

my $tfile = $space->tfile;

# "Foo_Bar.t"

The tryload method attempt to load the represented package using the "load" method and returns truthy/falsy based on whether the package was loaded.

tryload() (boolean)

{ since => '0.01', }

=example-1 tryload

package main;

use Venus::Space;

my $space = Venus::Space->new('c_p_a_n');

my $tryload = $space->tryload;

# 1

The use method executes a use statement within the package namespace specified.

use(string | tuple[string, string] $target, any @params) (Venus::Space)

{ since => '0.01', }

=example-1 use

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/goo');

my $use = $space->use('Venus');

# bless({ value => "foo/goo" }, "Venus::Space")

The unload method unloads a package space by nullifying its symbol table (setting all typeglobs to undef) and removing it from %INC. Unlike "purge", this method preserves symbol table entries, keeping the package visible. Unlike "scrub", this method nullifies entire typeglobs rather than individual slots.

unload() (Venus::Space)

{ since => '1.02', }

=example-1 unload

package main;

use Venus::Space;

# Bar::Gen is generated with $VERSION as 0.01

my $space = Venus::Space->new('Bar/Gen');

$space->load;

my $unload = $space->unload;

# bless({ value => "Bar::Gen" }, "Venus::Space")

# Bar::Gen->VERSION was 0.01, now undef

# Symbol table remains, $space->visible is 1

The unloaded method checks whether the package namespace is not loaded and returns truthy or falsy.

unloaded() (boolean)

{ since => '1.02', }

=example-1 unloaded

package main;

use Venus::Space;

my $space = Venus::Space->new('Kit');

$space->init;

$space->unload;

my $unloaded = $space->unloaded;

# 1

The unpatch method restores a subroutine which has been patched using the "patch" operation to its original subroutine reference. If no name is provided, this method will restore all subroutines have been patched. If a name is provided, this method will only restore the named subroutine has been patched.

unpatch(string @names) (Venus::Space)

{ since => '3.55', }

The variables method searches the package namespace for variables and returns their names.

variables() (within[arrayref, tuple[string, arrayref]])

{ since => '0.01', }

=example-1 variables

package Etc;

our $init = 0;
our $func = 1;

our @does = (1..4);
our %sets = (1..4);

package main;

use Venus::Space;

my $space = Venus::Space->new('etc');

my $variables = $space->variables;

# [
#   ["arrays", ["does"]],
#   ["hashes", ["sets"]],
#   ["scalars", ["func", "init"]],
# ]

The visible method returns truthy is the package namespace is visible, i.e. has symbols defined.

visible() (boolean)

{ since => '1.02', }

=example-1 visible

# given: synopsis

package main;

my $visible = $space->visible;

# 1

The version method returns the VERSION declared on the target package, if any.

version() (maybe[string])

{ since => '0.01', }

=example-1 version

package Foo::Boo;

sub import;

package main;

use Venus::Space;

my $space = Venus::Space->new('foo/boo');

my $version = $space->version;

# undef

package main;

use Venus::Space;

my $space = Venus::Space->new('Venus::Check');

$space->call('not_a_method');

# Error! (on.call.missing)

package main;

use Venus::Space;

my $space = Venus::Space->new('Venus::Check');

$space->around('not_a_method');

# Error! (on.around.missing)

package main;

use Venus::Space;

my $space = Venus::Space->new('Venus::Check');

$space->cop('not_a_method');

# Error! (on.cop.missing)

package main;

use Venus::Space;

my $space = Venus::Space->new('Venus::Check');

$space->eval('die');

# Error! (on.eval)

package main;

use Venus::Space;

my $space = Venus::Space->new('Fake::Package::NotReal');

$space->load;

# Error! (on.load)

t/Venus.t: present: authors t/Venus.t: present: license

cpanm Venus

perl -MCPAN -e shell
install Venus