package Zing::App;

use 5.014;

use strict;
use warnings;

use registry 'Zing::Types';
use routines;

use Data::Object::Class;
use Data::Object::ClassHas;
use Data::Object::Space;

our $VERSION = '0.27'; # VERSION

# ATTRIBUTES

has env => (
  is => 'ro',
  isa => 'Env',
  new => 1,
);

fun new_env($self) {
  require Zing::Env; Zing::Env->new(app => $self);
}

has host => (
  is => 'ro',
  isa => 'Str',
  init_arg => undef,
  new => 1,
);

fun new_host($self) {
  $self->env->host
}

has name => (
  is => 'ro',
  isa => 'Str',
  new => 1,
);

fun new_name($self) {
  'zing'
}

has pid => (
  is => 'ro',
  isa => 'Int',
  init_arg => undef,
  new => 1,
);

fun new_pid($self) {
  $$
}

# METHODS

method for(Any %args) {
  my %data = %{$self->env}; delete $data{app};
  require Zing::Env; Zing::Env->new(%data, %args)->app;
}

method cartridge(Any @args) {
  return $self->reify($self->cartridge_specification(@args));
}

method cartridge_namespace() {
  return [$self->name, 'cartridge'];
}

method cartridge_specification(Any @args) {
  return [$self->cartridge_namespace, [@args]];
}

method channel(Any @args) {
  return $self->reify($self->channel_specification(@args));
}

method channel_namespace() {
  return [$self->name, 'channel'];
}

method channel_specification(Any @args) {
  return [$self->channel_namespace, [@args]];
}

method cursor(Any @args) {
  return $self->reify($self->cursor_specification(@args));
}

method cursor_namespace() {
  return [$self->name, 'cursor'];
}

method cursor_specification(Any @args) {
  return [$self->cursor_namespace, [@args]];
}

method daemon(Any @args) {
  return $self->reify($self->daemon_specification(@args));
}

method daemon_namespace() {
  return [$self->name, 'daemon'];
}

method daemon_specification(Any @args) {
  return [$self->daemon_namespace, [@args]];
}

method data(Any @args) {
  return $self->reify($self->data_specification(@args));
}

method data_namespace() {
  return [$self->name, 'data'];
}

method data_specification(Any @args) {
  return [$self->data_namespace, [@args]];
}

method domain(Any @args) {
  return $self->reify($self->domain_specification(@args));
}

method domain_namespace() {
  return [$self->name, 'domain'];
}

method domain_specification(Any @args) {
  return [$self->domain_namespace, [@args]];
}

method encoder(Any @args) {
  return $self->reify($self->encoder_specification(@args));
}

method encoder_namespace() {
  return [$self->env->encoder];
}

method encoder_specification(Any @args) {
  return [$self->encoder_namespace, [@args]];
}

method fork(Any @args) {
  return $self->reify($self->fork_specification(@args));
}

method fork_namespace() {
  return [$self->name, 'fork'];
}

method fork_specification(Any @args) {
  return [$self->fork_namespace, [@args]];
}

method id(Any @args) {
  return $self->reify($self->id_specification(@args));
}

method id_namespace() {
  return [$self->name, 'i-d'];
}

method id_specification(Any @args) {
  return [$self->id_namespace, [@args]];
}

method journal(Any @args) {
  return $self->reify($self->journal_specification(@args));
}

method journal_namespace() {
  return [$self->name, 'journal'];
}

method journal_specification(Any @args) {
  return [$self->journal_namespace, [@args]];
}

method kernel(Any @args) {
  return $self->reify($self->kernel_specification(@args));
}

method kernel_namespace() {
  return [$self->name, 'kernel'];
}

method kernel_specification(Any @args) {
  return [$self->kernel_namespace, [@args]];
}

method keyval(Any @args) {
  return $self->reify($self->keyval_specification(@args));
}

method keyval_namespace() {
  return [$self->name, 'key-val'];
}

method keyval_specification(Any @args) {
  return [$self->keyval_namespace, [@args]];
}

method launcher(Any @args) {
  return $self->reify($self->launcher_specification(@args));
}

method launcher_namespace() {
  return [$self->name, 'launcher'];
}

method launcher_specification(Any @args) {
  return [$self->launcher_namespace, [@args]];
}

method logger(Any @args) {
  require FlightRecorder; FlightRecorder->new(level => 'info', @args);
}

method lookup(Any @args) {
  return $self->reify($self->lookup_specification(@args));
}

method lookup_namespace() {
  return [$self->name, 'lookup'];
}

method lookup_specification(Any @args) {
  return [$self->lookup_namespace, [@args]];
}

method mailbox(Any @args) {
  return $self->reify($self->mailbox_specification(@args));
}

method mailbox_namespace() {
  return [$self->name, 'mailbox'];
}

method mailbox_specification(Any @args) {
  return [$self->mailbox_namespace, [@args]];
}

method meta(Any @args) {
  return $self->reify($self->meta_specification(@args));
}

method meta_namespace() {
  return [$self->name, 'meta'];
}

method meta_specification(Any @args) {
  return [$self->meta_namespace, [@args]];
}

method process(Any @args) {
  return $self->reify($self->process_specification(@args));
}

method process_namespace() {
  return [$self->name, 'process'];
}

method process_specification(Any @args) {
  return [$self->process_namespace, [@args]];
}

method pubsub(Any @args) {
  return $self->reify($self->pubsub_specification(@args));
}

method pubsub_namespace() {
  return [$self->name, 'pub-sub'];
}

method pubsub_specification(Any @args) {
  return [$self->pubsub_namespace, [@args]];
}

method queue(Any @args) {
  return $self->reify($self->queue_specification(@args));
}

method queue_namespace() {
  return [$self->name, 'queue'];
}

method queue_specification(Any @args) {
  return [$self->queue_namespace, [@args]];
}

method reify(Tuple[ArrayRef, ArrayRef] $spec) {
  return $self->space(@{$spec->[0]})->build(@{$spec->[1]}, env => $self->env);
}

method repo(Any @args) {
  return $self->reify($self->repo_specification(@args));
}

method repo_namespace() {
  return [$self->name, 'repo'];
}

method repo_specification(Any @args) {
  return [$self->repo_namespace, [@args]];
}

method ring(Any @args) {
  return $self->reify($self->ring_specification(@args));
}

method ring_namespace() {
  return [$self->name, 'ring'];
}

method ring_specification(Any @args) {
  return [$self->ring_namespace, [@args]];
}

method ringer(Any @args) {
  return $self->reify($self->ringer_specification(@args));
}

method ringer_namespace() {
  return [$self->name, 'ringer'];
}

method ringer_specification(Any @args) {
  return [$self->ringer_namespace, [@args]];
}

method savepoint(Any @args) {
  return $self->reify($self->savepoint_specification(@args));
}

method savepoint_namespace() {
  return [$self->name, 'savepoint'];
}

method savepoint_specification(Any @args) {
  return [$self->savepoint_namespace, [@args]];
}

method scheduler(Any @args) {
  return $self->reify($self->scheduler_specification(@args));
}

method scheduler_namespace() {
  return [$self->name, 'scheduler'];
}

method scheduler_specification(Any @args) {
  return [$self->scheduler_namespace, [@args]];
}

method search(Any @args) {
  return $self->reify($self->search_specification(@args));
}

method search_namespace() {
  return [$self->name, 'search'];
}

method search_specification(Any @args) {
  return [$self->search_namespace, [@args]];
}

method simple(Any @args) {
  return $self->reify($self->simple_specification(@args));
}

method simple_namespace() {
  return [$self->name, 'simple'];
}

method simple_specification(Any @args) {
  return [$self->simple_namespace, [@args]];
}

method single(Any @args) {
  return $self->reify($self->single_specification(@args));
}

method single_namespace() {
  return [$self->name, 'single'];
}

method single_specification(Any @args) {
  return [$self->single_namespace, [@args]];
}

method space(Str @args) {
  return Data::Object::Space->new(join '/', (@args ? @args : $self->name));
}

method spawner(Any @args) {
  return $self->reify($self->spawner_specification(@args));
}

method spawner_namespace() {
  return [$self->name, 'spawner'];
}

method spawner_specification(Any @args) {
  return [$self->spawner_namespace, [@args]];
}

method store(Any @args) {
  return $self->reify($self->store_specification(@args));
}

method store_namespace() {
  return [$self->env->store];
}

method store_specification(Any @args) {
  return [$self->store_namespace, [encoder => $self->encoder, @args]];
}

method table(Any @args) {
  return $self->reify($self->table_specification(@args));
}

method table_namespace() {
  return [$self->name, 'table'];
}

method table_specification(Any @args) {
  return [$self->table_namespace, [@args]];
}

method term(Any @args) {
  require Zing::Term; Zing::Term->new(@args);
}

method timer(Any @args) {
  return $self->reify($self->timer_specification(@args));
}

method timer_namespace() {
  return [$self->name, 'timer'];
}

method timer_specification(Any @args) {
  return [$self->timer_namespace, [@args]];
}

method watcher(Any @args) {
  return $self->reify($self->watcher_specification(@args));
}

method watcher_namespace() {
  return [$self->name, 'watcher'];
}

method watcher_specification(Any @args) {
  return [$self->watcher_namespace, [@args]];
}

method worker(Any @args) {
  return $self->reify($self->worker_specification(@args));
}

method worker_namespace() {
  return [$self->name, 'worker'];
}

method worker_specification(Any @args) {
  return [$self->worker_namespace, [@args]];
}

method zang() {
  return ref($self)->new(name => 'Zing/Zang');
}

method zing(Any @args) {
  require Zing; Zing->new(@args);
}

1;



=encoding utf8

=head1 NAME

Zing::App - Object Reifier

=cut

=head1 ABSTRACT

Object Reifier with Dependency Injection

=cut

=head1 SYNOPSIS

  use Zing::App;

  my $app = Zing::App->new;

  # $app->queue(name => 'tasks')->send({
  #   job => time,
  #   ...
  # });

=cut

=head1 DESCRIPTION

This package provides an object which can dynamically load (reify) other
L<Zing> objects with dependencies.

=cut

=head1 LIBRARIES

This package uses type constraints from:

L<Zing::Types>

=cut

=head1 ATTRIBUTES

This package has the following attributes:

=cut

=head2 env

  env(Env)

This attribute is read-only, accepts C<(Env)> values, and is optional.

=cut

=head2 host

  host(Str)

This attribute is read-only, accepts C<(Str)> values, and is optional.

=cut

=head2 name

  name(Str)

This attribute is read-only, accepts C<(Str)> values, and is optional.

=cut

=head2 pid

  pid(Int)

This attribute is read-only, accepts C<(Int)> values, and is optional.

=cut

=head1 METHODS

This package implements the following methods:

=cut

=head2 cartridge

  cartridge(Any @args) : Cartridge

The cartridge method returns a new L<Zing::Cartridge> object based on the current C<env>.

=over 4

=item cartridge example #1

  # given: synopsis

  my $cartridge = $app->cartridge(
    name => 'myapp',
  );

  # Zing::Cartridge->new(...)

=back

=cut

=head2 cartridge_namespace

  cartridge_namespace() : ArrayRef[Str]

The cartridge_namespace method returns a wordlist that represents a
I<cartridge> class name.

=over 4

=item cartridge_namespace example #1

  # given: synopsis

  $app->cartridge_namespace;

  # ['zing', 'cartridge']

=back

=cut

=head2 cartridge_specification

  cartridge_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The cartridge_specification method returns a I<cartridge> specification, class
name and args, for the reifier.

=over 4

=item cartridge_specification example #1

  # given: synopsis

  $app->cartridge_specification;

  # [['zing', 'cartridge'], [@args]]

=back

=cut

=head2 channel

  channel(Any @args) : Channel

The channel method returns a new L<Zing::Channel> object based on the currenrt C<env>.

=over 4

=item channel example #1

  # given: synopsis

  my $channel = $app->channel(
    name => 'messages',
  );

  # Zing::Channel->new(...)

=back

=cut

=head2 channel_namespace

  channel_namespace() : ArrayRef[Str]

The channel_namespace method returns a wordlist that represents a I<channel>
class name.

=over 4

=item channel_namespace example #1

  # given: synopsis

  $app->channel_namespace;

  # ['zing', 'channel']

=back

=cut

=head2 channel_specification

  channel_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The channel_specification method returns a I<channel> specification, class name
and args, for the reifier.

=over 4

=item channel_specification example #1

  # given: synopsis

  $app->channel_specification;

  # [['zing', 'channel'], [@args]]

=back

=cut

=head2 cursor

  cursor(Any @args) : Cursor

The cursor method returns a new L<Zing::Cursor> object based on the current C<env>.

=over 4

=item cursor example #1

  # given: synopsis

  my $cursor = $app->cursor(
    lookup => $app->lookup(
      name => 'people',
    )
  );

  # Zing::Cursor->new(...)

=back

=cut

=head2 cursor_namespace

  cursor_namespace() : ArrayRef[Str]

The cursor_namespace method returns a wordlist that represents a I<cursor>
class name.

=over 4

=item cursor_namespace example #1

  # given: synopsis

  $app->cursor_namespace;

  # ['zing', 'cursor']

=back

=cut

=head2 cursor_specification

  cursor_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The cursor_specification method returns a I<cursor> specification, class name
and args, for the reifier.

=over 4

=item cursor_specification example #1

  # given: synopsis

  $app->cursor_specification;

  # [['zing', 'cursor'], [@args]]

=back

=cut

=head2 daemon

  daemon(Any @args) : Daemon

The daemon method returns a new L<Zing::Daemon> object based on the currenrt C<env>.

=over 4

=item daemon example #1

  # given: synopsis

  my $daemon = $app->daemon(
    cartridge => $app->cartridge(
      name => 'myapp',
    )
  );

  # Zing::Daemon->new(...)

=back

=cut

=head2 daemon_namespace

  daemon_namespace() : ArrayRef[Str]

The daemon_namespace method returns a wordlist that represents a I<daemon>
class name.

=over 4

=item daemon_namespace example #1

  # given: synopsis

  $app->daemon_namespace;

  # ['zing', 'daemon']

=back

=cut

=head2 daemon_specification

  daemon_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The daemon_specification method returns a I<daemon> specification, class name
and args, for the reifier.

=over 4

=item daemon_specification example #1

  # given: synopsis

  $app->daemon_specification;

  # [['zing', 'daemon'], [@args]]

=back

=cut

=head2 data

  data(Any @args) : Data

The data method returns a new L<Zing::Data> object based on the current C<env>.

=over 4

=item data example #1

  # given: synopsis

  my $data = $app->data(
    name => 'random',
  );

  # Zing::Data->new(...)

=back

=cut

=head2 data_namespace

  data_namespace() : ArrayRef[Str]

The data_namespace method returns a wordlist that represents a I<data> class
name.

=over 4

=item data_namespace example #1

  # given: synopsis

  $app->data_namespace;

  # ['zing', 'data']

=back

=cut

=head2 data_specification

  data_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The data_specification method returns a I<data> specification, class name and
args, for the reifier.

=over 4

=item data_specification example #1

  # given: synopsis

  $app->data_specification;

  # [['zing', 'data'], [@args]]

=back

=cut

=head2 domain

  domain(Any @args) : Domain

The domain method returns a new L<Zing::Domain> object based on the currenrt C<env>.

=over 4

=item domain example #1

  # given: synopsis

  my $domain = $app->domain(
    name => 'person',
  );

  # Zing::Domain->new(...)

=back

=cut

=head2 domain_namespace

  domain_namespace() : ArrayRef[Str]

The domain_namespace method returns a wordlist that represents a I<domain>
class name.

=over 4

=item domain_namespace example #1

  # given: synopsis

  $app->domain_namespace;

  # ['zing', 'domain']

=back

=cut

=head2 domain_specification

  domain_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The domain_specification method returns a I<domain> specification, class name
and args, for the reifier.

=over 4

=item domain_specification example #1

  # given: synopsis

  $app->domain_specification;

  # [['zing', 'domain'], [@args]]

=back

=cut

=head2 encoder

  encoder(Any @args) : Encoder

The encoder method returns a new L<Zing::Encoder> object based on the current C<env>.

=over 4

=item encoder example #1

  # given: synopsis

  my $encoder = $app->encoder;

  # Zing::Encoder->new

=back

=cut

=head2 encoder_namespace

  encoder_namespace() : ArrayRef[Str]

The encoder_namespace method returns a wordlist that represents a I<encoder>
class name.

=over 4

=item encoder_namespace example #1

  # given: synopsis

  $app->encoder_namespace;

  # ['zing', 'encoder']

=back

=cut

=head2 encoder_specification

  encoder_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The encoder_specification method returns a I<encoder> specification, class name
and args, for the reifier.

=over 4

=item encoder_specification example #1

  # given: synopsis

  $app->encoder_specification;

  # [['zing', 'encoder'], [@args]]

=back

=cut

=head2 for

  for(Any %args) : App

The for method changes the C<env> and returns a new C<app> object.

=over 4

=item for example #1

  # given: synopsis

  $app = $app->for(
    handle => 'myapp',
    target => 'us-east'
  );

=back

=cut

=head2 fork

  fork(Any @args) : Fork

The fork method returns a new L<Zing::Fork> object based on the currenrt C<env>.

=over 4

=item fork example #1

  # given: synopsis

  my $fork = $app->fork(
    parent => $app->process,
    scheme => ['MyApp', [], 1],
  );

  # Zing::Fork->new(...)

=back

=cut

=head2 fork_namespace

  fork_namespace() : ArrayRef[Str]

The fork_namespace method returns a wordlist that represents a I<fork> class
name.

=over 4

=item fork_namespace example #1

  # given: synopsis

  $app->fork_namespace;

  # ['zing', 'fork']

=back

=cut

=head2 fork_specification

  fork_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The fork_specification method returns a I<fork> specification, class name and
args, for the reifier.

=over 4

=item fork_specification example #1

  # given: synopsis

  $app->fork_specification;

  # [['zing', 'fork'], [@args]]

=back

=cut

=head2 id

  id(Any @args) : ID

The id method returns a new L<Zing::ID> object based on the current C<env>.

=over 4

=item id example #1

  # given: synopsis

  my $id = $app->id;

  # Zing::ID->new(...)

=back

=cut

=head2 id_namespace

  id_namespace() : ArrayRef[Str]

The id_namespace method returns a wordlist that represents a I<id> class name.

=over 4

=item id_namespace example #1

  # given: synopsis

  $app->id_namespace;

  # ['zing', 'i-d']

=back

=cut

=head2 id_specification

  id_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The id_specification method returns a I<id> specification, class name and args,
for the reifier.

=over 4

=item id_specification example #1

  # given: synopsis

  $app->id_specification;

  # [['zing', 'i-d'], [@args]]

=back

=cut

=head2 journal

  journal(Any @args) : Journal

The journal method returns a new L<Zing::Journal> object based on the currenrt C<env>.

=over 4

=item journal example #1

  # given: synopsis

  my $journal = $app->journal;

  # Zing::Journal->new

=back

=cut

=head2 journal_namespace

  journal_namespace() : ArrayRef[Str]

The journal_namespace method returns a wordlist that represents a I<journal>
class name.

=over 4

=item journal_namespace example #1

  # given: synopsis

  $app->journal_namespace;

  # ['zing', 'journal']

=back

=cut

=head2 journal_specification

  journal_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The journal_specification method returns a I<journal> specification, class name
and args, for the reifier.

=over 4

=item journal_specification example #1

  # given: synopsis

  $app->journal_specification;

  # [['zing', 'journal'], [@args]]

=back

=cut

=head2 kernel

  kernel(Any @args) : Kernel

The kernel method returns a new L<Zing::Kernel> object based on the current C<env>.

=over 4

=item kernel example #1

  # given: synopsis

  my $kernel = $app->kernel(
    scheme => ['MyApp', [], 1],
  );

  # Zing::Kernel->new(...)

=back

=cut

=head2 kernel_namespace

  kernel_namespace() : ArrayRef[Str]

The kernel_namespace method returns a wordlist that represents a I<kernel>
class name.

=over 4

=item kernel_namespace example #1

  # given: synopsis

  $app->kernel_namespace;

  # ['zing', 'kernel']

=back

=cut

=head2 kernel_specification

  kernel_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The kernel_specification method returns a I<kernel> specification, class name
and args, for the reifier.

=over 4

=item kernel_specification example #1

  # given: synopsis

  $app->kernel_specification;

  # [['zing', 'kernel'], [@args]]

=back

=cut

=head2 keyval

  keyval(Any @args) : KeyVal

The keyval method returns a new L<Zing::KeyVal> object based on the currenrt C<env>.

=over 4

=item keyval example #1

  # given: synopsis

  my $keyval = $app->keyval(
    name => 'backup',
  );

  # Zing::KeyVal->new(...)

=back

=cut

=head2 keyval_namespace

  keyval_namespace() : ArrayRef[Str]

The keyval_namespace method returns a wordlist that represents a I<keyval>
class name.

=over 4

=item keyval_namespace example #1

  # given: synopsis

  $app->keyval_namespace;

  # ['zing', 'key-val']

=back

=cut

=head2 keyval_specification

  keyval_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The keyval_specification method returns a I<keyval> specification, class name
and args, for the reifier.

=over 4

=item keyval_specification example #1

  # given: synopsis

  $app->keyval_specification;

  # [['zing', 'key-val'], [@args]]

=back

=cut

=head2 launcher

  launcher(Any @args) : Launcher

The launcher method returns a new L<Zing::Launcher> object based on the currenrt C<env>.

=over 4

=item launcher example #1

  # given: synopsis

  my $launcher = $app->launcher;

  # Zing::Launcher->new(...)

=back

=cut

=head2 launcher_namespace

  launcher_namespace() : ArrayRef[Str]

The launcher_namespace method returns a wordlist that represents a I<launcher>
class name.

=over 4

=item launcher_namespace example #1

  # given: synopsis

  $app->launcher_namespace;

  # ['zing', 'launcher']

=back

=cut

=head2 launcher_specification

  launcher_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The launcher_specification method returns a I<launcher> specification, class
name and args, for the reifier.

=over 4

=item launcher_specification example #1

  # given: synopsis

  $app->launcher_specification;

  # [['zing', 'launcher'], [@args]]

=back

=cut

=head2 logger

  logger(Any @args) : Logger

The logger method returns a new L<FlightRecorder> object based on the currenrt C<env>.

=over 4

=item logger example #1

  # given: synopsis

  my $logger = $app->logger;

  # FlightRecorder->new(...)

=back

=cut

=head2 lookup

  lookup(Any @args) : Lookup

The lookup method returns a new L<Zing::Lookup> object based on the currenrt C<env>.

=over 4

=item lookup example #1

  # given: synopsis

  my $lookup = $app->lookup(
    name => 'people',
  );

  # Zing::Lookup->new(...)

=back

=cut

=head2 lookup_namespace

  lookup_namespace() : ArrayRef[Str]

The lookup_namespace method returns a wordlist that represents a I<lookup>
class name.

=over 4

=item lookup_namespace example #1

  # given: synopsis

  $app->lookup_namespace;

  # ['zing', 'lookup']

=back

=cut

=head2 lookup_specification

  lookup_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The lookup_specification method returns a I<lookup> specification, class name
and args, for the reifier.

=over 4

=item lookup_specification example #1

  # given: synopsis

  $app->lookup_specification;

  # [['zing', 'lookup'], [@args]]

=back

=cut

=head2 mailbox

  mailbox(Any @args) : Mailbox

The mailbox method returns a new L<Zing::Mailbox> object based on the currenrt C<env>.

=over 4

=item mailbox example #1

  # given: synopsis

  my $mailbox = $app->mailbox(
    name => 'shared',
  );

  # Zing::Mailbox->new(...)

=back

=cut

=head2 mailbox_namespace

  mailbox_namespace() : ArrayRef[Str]

The mailbox_namespace method returns a wordlist that represents a I<mailbox>
class name.

=over 4

=item mailbox_namespace example #1

  # given: synopsis

  $app->mailbox_namespace;

  # ['zing', 'mailbox']

=back

=cut

=head2 mailbox_specification

  mailbox_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The mailbox_specification method returns a I<mailbox> specification, class name
and args, for the reifier.

=over 4

=item mailbox_specification example #1

  # given: synopsis

  $app->mailbox_specification;

  # [['zing', 'mailbox'], [@args]]

=back

=cut

=head2 meta

  meta(Any @args) : Meta

The meta method returns a new L<Zing::Meta> object based on the currenrt C<env>.

=over 4

=item meta example #1

  # given: synopsis

  my $meta = $app->meta(
    name => rand,
  );

  # Zing::Meta->new(...)

=back

=cut

=head2 meta_namespace

  meta_namespace() : ArrayRef[Str]

The meta_namespace method returns a wordlist that represents a I<meta> class
name.

=over 4

=item meta_namespace example #1

  # given: synopsis

  $app->meta_namespace;

  # ['zing', 'meta']

=back

=cut

=head2 meta_specification

  meta_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The meta_specification method returns a I<meta> specification, class name and
args, for the reifier.

=over 4

=item meta_specification example #1

  # given: synopsis

  $app->meta_specification;

  # [['zing', 'meta'], [@args]]

=back

=cut

=head2 process

  process(Any @args) : Process

The process method returns a new L<Zing::Process> object based on the currenrt C<env>.

=over 4

=item process example #1

  # given: synopsis

  my $process = $app->process;

  # Zing::Process->new(...)

=back

=cut

=head2 process_namespace

  process_namespace() : ArrayRef[Str]

The process_namespace method returns a wordlist that represents a I<process>
class name.

=over 4

=item process_namespace example #1

  # given: synopsis

  $app->process_namespace;

  # ['zing', 'process']

=back

=cut

=head2 process_specification

  process_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The process_specification method returns a I<process> specification, class name
and args, for the reifier.

=over 4

=item process_specification example #1

  # given: synopsis

  $app->process_specification;

  # [['zing', 'process'], [@args]]

=back

=cut

=head2 pubsub

  pubsub(Any @args) : PubSub

The pubsub method returns a new L<Zing::PubSub> object based on the currenrt C<env>.

=over 4

=item pubsub example #1

  # given: synopsis

  my $pubsub = $app->pubsub(
    name => 'commands',
  );

  # Zing::PubSub->new(...)

=back

=cut

=head2 pubsub_namespace

  pubsub_namespace() : ArrayRef[Str]

The pubsub_namespace method returns a wordlist that represents a I<pubsub>
class name.

=over 4

=item pubsub_namespace example #1

  # given: synopsis

  $app->pubsub_namespace;

  # ['zing', 'pub-sub']

=back

=cut

=head2 pubsub_specification

  pubsub_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

the pubsub_specification method returns a i<pubsub> specification, class name
and args, for the reifier.

=over 4

=item pubsub_specification example #1

  # given: synopsis

  $app->pubsub_specification;

  # [['zing', 'pub-sub'], [@args]]

=back

=cut

=head2 queue

  queue(Any @args) : Queue

The queue method returns a new L<Zing::Queue> object based on the currenrt C<env>.

=over 4

=item queue example #1

  # given: synopsis

  my $queue = $app->queue(
    name => 'tasks',
  );

  # Zing::Queue->new(...)

=back

=cut

=head2 queue_namespace

  queue_namespace() : ArrayRef[Str]

The queue_namespace method returns a wordlist that represents a I<queue> class
name.

=over 4

=item queue_namespace example #1

  # given: synopsis

  $app->queue_namespace;

  # ['zing', 'queue']

=back

=cut

=head2 queue_specification

  queue_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The queue_specification method returns a I<queue> specification, class name and
args, for the reifier.

=over 4

=item queue_specification example #1

  # given: synopsis

  $app->queue_specification;

  # [['zing', 'queue'], [@args]]

=back

=cut

=head2 reify

  reify(Tuple[ArrayRef, ArrayRef] $spec) : Object

The reify method executes a specification, reifies and returns an object.

=over 4

=item reify example #1

  # given: synopsis

  my $queue = $app->reify(
    [['zing', 'queue'], ['name', 'tasks']],
  );

  # Zing::Queue->new(
  #   name => 'tasks'
  # )

=back

=cut

=head2 repo

  repo(Any @args) : Repo

The repo method returns a new L<Zing::Repo> object based on the currenrt C<env>.

=over 4

=item repo example #1

  # given: synopsis

  my $repo = $app->repo(
    name => '$registry',
  );

  # Zing::Repo->new(...)

=back

=cut

=head2 repo_namespace

  repo_namespace() : ArrayRef[Str]

The repo_namespace method returns a wordlist that represents a I<repo> class
name.

=over 4

=item repo_namespace example #1

  # given: synopsis

  $app->repo_namespace;

  # ['zing', 'repo']

=back

=cut

=head2 repo_specification

  repo_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The repo_specification method returns a I<repo> specification, class name and
args, for the reifier.

=over 4

=item repo_specification example #1

  # given: synopsis

  $app->repo_specification;

  # [['zing', 'repo'], [@args]]

=back

=cut

=head2 ring

  ring(Any @args) : Ring

The ring method returns a new L<Zing::Ring> object based on the currenrt C<env>.

=over 4

=item ring example #1

  # given: synopsis

  my $ring = $app->ring(
    processes => [
      $app->process,
      $app->process,
    ],
  );

  # Zing::Ring->new(...)

=back

=cut

=head2 ring_namespace

  ring_namespace() : ArrayRef[Str]

The ring_namespace method returns a wordlist that represents a I<ring> class
name.

=over 4

=item ring_namespace example #1

  # given: synopsis

  $app->ring_namespace;

  # ['zing', 'ring']

=back

=cut

=head2 ring_specification

  ring_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The ring_specification method returns a I<ring> specification, class name and
args, for the reifier.

=over 4

=item ring_specification example #1

  # given: synopsis

  $app->ring_specification;

  # [['zing', 'ring'], [@args]]

=back

=cut

=head2 ringer

  ringer(Any @args) : Ring

The ringer method returns a new L<Zing::Ringer> object based on the currenrt C<env>.

=over 4

=item ringer example #1

  # given: synopsis

  my $ringer = $app->ringer(
    schemes => [
      ['MyApp1', [], 1],
      ['MyApp2', [], 1],
    ],
  );

  # Zing::Ringer->new(...)

=back

=cut

=head2 ringer_namespace

  ringer_namespace() : ArrayRef[Str]

The ringer_namespace method returns a wordlist that represents a I<ringer>
class name.

=over 4

=item ringer_namespace example #1

  # given: synopsis

  $app->ringer_namespace;

  # ['zing', 'ringer']

=back

=cut

=head2 ringer_specification

  ringer_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The ringer_specification method returns a I<ringer> specification, class name
and args, for the reifier.

=over 4

=item ringer_specification example #1

  # given: synopsis

  $app->ringer_specification;

  # [['zing', 'ringer'], [@args]]

=back

=cut

=head2 savepoint

  savepoint(Any @args) : Savepoint

The savepoint method returns a new L<Zing::Savepoint> object based on the currenrt C<env>.

=over 4

=item savepoint example #1

  # given: synopsis

  my $savepoint = $app->savepoint(
    lookup => $app->lookup(
      name => 'people',
    )
  );

  # Zing::Savepoint->new(...)

=back

=cut

=head2 savepoint_namespace

  savepoint_namespace() : ArrayRef[Str]

The savepoint_namespace method returns a wordlist that represents a
I<savepoint> class name.

=over 4

=item savepoint_namespace example #1

  # given: synopsis

  $app->savepoint_namespace;

  # ['zing', 'savepoint']

=back

=cut

=head2 savepoint_specification

  savepoint_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The savepoint_specification method returns a I<savepoint> specification, class
name and args, for the reifier.

=over 4

=item savepoint_specification example #1

  # given: synopsis

  $app->savepoint_specification;

  # [['zing', 'savepoint'], [@args]]

=back

=cut

=head2 scheduler

  scheduler(Any @args) : Scheduler

The scheduler method returns a new L<Zing::Scheduler> object based on the currenrt C<env>.

=over 4

=item scheduler example #1

  # given: synopsis

  my $scheduler = $app->scheduler;

  # Zing::Scheduler->new(...)

=back

=cut

=head2 scheduler_namespace

  scheduler_namespace() : ArrayRef[Str]

The scheduler_namespace method returns a wordlist that represents a
I<scheduler> class name.

=over 4

=item scheduler_namespace example #1

  # given: synopsis

  $app->scheduler_namespace;

  # ['zing', 'scheduler']

=back

=cut

=head2 scheduler_specification

  scheduler_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The scheduler_specification method returns a I<scheduler> specification, class
name and args, for the reifier.

=over 4

=item scheduler_specification example #1

  # given: synopsis

  $app->scheduler_specification;

  # [['zing', 'scheduler'], [@args]]

=back

=cut

=head2 search

  search(Any @args) : Search

The search method returns a new L<Zing::Search> object based on the currenrt C<env>.

=over 4

=item search example #1

  # given: synopsis

  my $search = $app->search;

  # Zing::Search->new(...)

=back

=cut

=head2 search_namespace

  search_namespace() : ArrayRef[Str]

The search_namespace method returns a wordlist that represents a I<search>
class name.

=over 4

=item search_namespace example #1

  # given: synopsis

  $app->search_namespace;

  # ['zing', 'search']

=back

=cut

=head2 search_specification

  search_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The search_specification method returns a I<search> specification, class name
and args, for the reifier.

=over 4

=item search_specification example #1

  # given: synopsis

  $app->search_specification;

  # [['zing', 'search'], [@args]]

=back

=cut

=head2 simple

  simple(Any @args) : Simple

The simple method returns a new L<Zing::Simple> object based on the currenrt C<env>.

=over 4

=item simple example #1

  # given: synopsis

  my $simple = $app->simple;

  # Zing::Simple->new(...)

=back

=cut

=head2 simple_namespace

  simple_namespace() : ArrayRef[Str]

The simple_namespace method returns a wordlist that represents a I<simple>
class name.

=over 4

=item simple_namespace example #1

  # given: synopsis

  $app->simple_namespace;

  # ['zing', 'simple']

=back

=cut

=head2 simple_specification

  simple_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The simple_specification method returns a I<simple> specification, class name
and args, for the reifier.

=over 4

=item simple_specification example #1

  # given: synopsis

  $app->simple_specification;

  # [['zing', 'simple'], [@args]]

=back

=cut

=head2 single

  single(Any @args) : Single

The single method returns a new L<Zing::Single> object based on the currenrt C<env>.

=over 4

=item single example #1

  # given: synopsis

  my $single = $app->single;

  # Zing::Single->new(...)

=back

=cut

=head2 single_namespace

  single_namespace() : ArrayRef[Str]

The single_namespace method returns a wordlist that represents a I<single>
class name.

=over 4

=item single_namespace example #1

  # given: synopsis

  $app->single_namespace;

  # ['zing', 'single']

=back

=cut

=head2 single_specification

  single_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The single_specification method returns a I<single> specification, class name
and args, for the reifier.

=over 4

=item single_specification example #1

  # given: synopsis

  $app->single_specification;

  # [['zing', 'single'], [@args]]

=back

=cut

=head2 space

  space(Str @args) : Space

The space method returns a new L<Data::Object::Space> object.

=over 4

=item space example #1

  # given: synopsis

  my $space = $app->space(
    'zing',
  );

  # Data::Object::Space->new(...)

=back

=cut

=head2 spawner

  spawner(Any @args) : Spawner

The spawner method returns a new L<Zing::Spawner> object based on the currenrt C<env>.

=over 4

=item spawner example #1

  # given: synopsis

  my $spawner = $app->spawner;

  # Zing::Spawner->new(...)

=back

=cut

=head2 spawner_namespace

  spawner_namespace() : ArrayRef[Str]

The spawner_namespace method returns a wordlist that represents a I<spawner>
class name.

=over 4

=item spawner_namespace example #1

  # given: synopsis

  $app->spawner_namespace;

  # ['zing', 'spawner']

=back

=cut

=head2 spawner_specification

  spawner_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The spawner_specification method returns a I<spawner> specification, class name
and args, for the reifier.

=over 4

=item spawner_specification example #1

  # given: synopsis

  $app->spawner_specification;

  # [['zing', 'spawner'], [@args]]

=back

=cut

=head2 store

  store(Any @args) : Store

The store method returns a new L<Zing::Store> object based on the currenrt C<env>.

=over 4

=item store example #1

  # given: synopsis

  my $store = $app->store;

  # Zing::Store::Hash->new(...)

  # e.g.
  # $app->env->store # Zing::Store::Hash

  # e.g.
  # $ENV{ZING_STORE} # Zing::Store::Hash

=back

=cut

=head2 store_namespace

  store_namespace() : ArrayRef[Str]

The store_namespace method returns a wordlist that represents a I<store> class
name.

=over 4

=item store_namespace example #1

  # given: synopsis

  $app->store_namespace;

  # $ENV{ZING_STORE}

=back

=cut

=head2 store_specification

  store_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The store_specification method returns a I<store> specification, class name and
args, for the reifier.

=over 4

=item store_specification example #1

  # given: synopsis

  $app->store_specification;

  # [['zing', 'store'], [@args]]

=back

=cut

=head2 table

  table(Any @args) : Table

The table method returns a new L<Zing::Table> object based on the currenrt C<env>.

=over 4

=item table example #1

  # given: synopsis

  my $table = $app->table(
    name => 'people',
  );

  # Zing::Table->new(...)

=back

=cut

=head2 table_namespace

  table_namespace() : ArrayRef[Str]

The table_namespace method returns a wordlist that represents a I<table> class
name.

=over 4

=item table_namespace example #1

  # given: synopsis

  $app->table_namespace;

  # ['zing', 'table']

=back

=cut

=head2 table_specification

  table_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The table_specification method returns a I<table> specification, class name and
args, for the reifier.

=over 4

=item table_specification example #1

  # given: synopsis

  $app->table_specification;

  # [['zing', 'table'], [@args]]

=back

=cut

=head2 term

  term(Any @args) : Term

The term method returns a new L<Zing::Term> object based on the currenrt C<env>.

=over 4

=item term example #1

  # given: synopsis

  my $term = $app->term(
    $app->process,
  );

  # Zing::Term->new(...)

=back

=cut

=head2 timer

  timer(Any @args) : Timer

The timer method returns a new L<Zing::Timer> object based on the currenrt C<env>.

=over 4

=item timer example #1

  # given: synopsis

  my $timer = $app->timer;

  # Zing::Timer->new(...)

=back

=cut

=head2 timer_namespace

  timer_namespace() : ArrayRef[Str]

The timer_namespace method returns a wordlist that represents a I<timer> class
name.

=over 4

=item timer_namespace example #1

  # given: synopsis

  $app->timer_namespace;

  # ['zing', 'timer']

=back

=cut

=head2 timer_specification

  timer_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The timer_specification method returns a I<timer> specification, class name and
args, for the reifier.

=over 4

=item timer_specification example #1

  # given: synopsis

  $app->timer_specification;

  # [['zing', 'timer'], [@args]]

=back

=cut

=head2 watcher

  watcher(Any @args) : Watcher

The watcher method returns a new L<Zing::Watcher> object based on the currenrt C<env>.

=over 4

=item watcher example #1

  # given: synopsis

  my $watcher = $app->watcher;

  # Zing::Watcher->new(...)

=back

=cut

=head2 watcher_namespace

  watcher_namespace() : ArrayRef[Str]

The watcher_namespace method returns a wordlist that represents a I<watcher>
class name.

=over 4

=item watcher_namespace example #1

  # given: synopsis

  $app->watcher_namespace;

  # ['zing', 'watcher']

=back

=cut

=head2 watcher_specification

  watcher_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The watcher_specification method returns a I<watcher> specification, class name
and args, for the reifier.

=over 4

=item watcher_specification example #1

  # given: synopsis

  $app->watcher_specification;

  # [['zing', 'watcher'], [@args]]

=back

=cut

=head2 worker

  worker(Any @args) : Worker

The worker method returns a new L<Zing::Worker> object based on the currenrt C<env>.

=over 4

=item worker example #1

  # given: synopsis

  my $worker = $app->worker;

  # Zing::Worker->new(...)

=back

=cut

=head2 worker_namespace

  worker_namespace() : ArrayRef[Str]

The worker_namespace method returns a wordlist that represents a I<worker>
class name.

=over 4

=item worker_namespace example #1

  # given: synopsis

  $app->worker_namespace;

  # ['zing', 'worker']

=back

=cut

=head2 worker_specification

  worker_specification(Any @args) : Tuple[ArrayRef, ArrayRef]

The worker_specification method returns a I<worker> specification, class name
and args, for the reifier.

=over 4

=item worker_specification example #1

  # given: synopsis

  $app->worker_specification;

  # [['zing', 'worker'], [@args]]

=back

=cut

=head2 zang

  zang() : App

The zang method returns a new L<Zing::Zang> object.

=over 4

=item zang example #1

  # given: synopsis

  $app = $app->zang;

  # Zing::App->new(name => 'zing/zang')

=back

=cut

=head2 zing

  zing(Any @args) : Zing

The zing method returns a new L<Zing> object.

=over 4

=item zing example #1

  # given: synopsis

  my $zing = $app->zing(
    scheme => ['MyApp', [], 1],
  );

  # Zing->new(...)

=back

=cut

=head1 AUTHOR

Al Newkirk, C<awncorp@cpan.org>

=head1 LICENSE

Copyright (C) 2011-2019, Al Newkirk, et al.

This is free software; you can redistribute it and/or modify it under the terms
of the The Apache License, Version 2.0, as elucidated in the L<"license
file"|https://github.com/cpanery/zing/blob/master/LICENSE>.

=head1 PROJECT

L<Wiki|https://github.com/cpanery/zing/wiki>

L<Project|https://github.com/cpanery/zing>

L<Initiatives|https://github.com/cpanery/zing/projects>

L<Milestones|https://github.com/cpanery/zing/milestones>

L<Contributing|https://github.com/cpanery/zing/blob/master/CONTRIBUTE.md>

L<Issues|https://github.com/cpanery/zing/issues>

=cut