view release on metacpan or  search on metacpan

lib/Test/WriteVariants/Context.pm  view on Meta::CPAN

        push @code, (ref $setting) ? $setting->get_code : $setting;
    }
    return join "", @code;
}

=head2 get_var

search backwards through list of settings, stop at first match

=cut

sub get_var
{
    my ($self, $name, $type) = @_;
    for my $setting (reverse @$self)
    {
        next unless $setting;
        my @value = $setting->get_var($name, $type);
        return $value[0] if @value;
    }
    return;
}

=head2 get_env_var

search backwards through list of settings, stop at first match (implies EnvVar)

=head2 get_our_var

search backwards through list of settings, stop at first match (implies OurVar)

=head2 get_module_use

search backwards through list of settings, stop at first match (implies ModuleUse)

=head2 get_meta_info

search backwards through list of settings, stop at first match (implies MetaInfo)

=cut

sub get_env_var    { my ($self, $name) = @_; return $self->get_var($name, $ContextClass . '::EnvVar') }
sub get_our_var    { my ($self, $name) = @_; return $self->get_var($name, $ContextClass . '::OurVar') }
sub get_module_use { my ($self, $name) = @_; return $self->get_var($name, $ContextClass . '::ModuleUse') }
sub get_meta_info  { my ($self, $name) = @_; return $self->get_var($name, $ContextClass . '::MetaInfo') }

{

    package Test::WriteVariants::Context::BaseItem;
    use strict;
    use warnings;
    require Data::Dumper;
    require Carp;

    # base class for an item (a name-value-type triple)

    sub new
    {
        my ($class, $name, $value) = @_;

        my $self = bless {} => $class;
        $self->name($name);
        $self->value($value);

        return $self;
    }

    sub name
    {
        my $self = shift;
        $self->{name} = shift if @_;
        return $self->{name};
    }

    sub value
    {
        my $self = shift;
        $self->{value} = shift if @_;
        return $self->{value};
    }

    sub get_code
    {
        return '';
    }

    sub get_var
    {
        my ($self, $name, $type) = @_;
        return if $type && !$self->isa($type);    # empty list
        return if $name ne $self->name;           # empty list
        return $self->value;                      # scalar
    }

    sub quote_values_as_perl
    {
        my $self = shift;
        ## no critic (BuiltinFunctions::ProhibitComplexMappings)
        my @perl_values = map {
            my $val = Data::Dumper->new([$_])->Terse(1)->Purity(1)->Useqq(1)->Sortkeys(1)->Dump;
            chomp $val;
            $val;
        } @_;
        Carp::confess("quote_values_as_perl called with multiple items in scalar context (@perl_values)")
          if @perl_values > 1 && !wantarray;
        return $perl_values[0] unless wantarray;
        return @perl_values;
    }

    # utility method to get a new composite when you only have a value object
    sub new_composite { $ContextClass->new(@_) }

}    # ::BaseItem

{

    package Test::WriteVariants::Context::EnvVar;
    use strict;
    use warnings;
    use base 'Test::WriteVariants::Context::BaseItem';