view release on metacpan or  search on metacpan

lib/CHI/Cascade/Rule.pm  view on Meta::CPAN

    }, ref($class) || $class;

    if ( $opts{run_instance} ) {
        $self->{run_instance} = $opts{run_instance};
        weaken $self->{run_instance};   # It is against memory leaks
    }

    weaken $self->{cascade};            # It is against memory leaks
    $self->{resolved_depends} = undef;

    $self;
}

sub qr_params {
    my $self = shift;

    if (@_) {
        $self->{qr_params} = [ @_ ];
    }
    else {
        return @{ $self->{qr_params} };
    }
}

sub depends {
    my $self = shift;

    return $self->{resolved_depends}
      if $self->{resolved_depends};

    if ( ref( $self->{depends} ) eq 'CODE' ) {
        my $res = $self->{depends}->( $self, $self->qr_params );

        $self->{resolved_depends} = ref($res) eq 'ARRAY' ? [ @$res ] : [ $res ];
    }
    else {
        $self->{resolved_depends} = [ @{ $self->{depends} } ];
    }

    for ( @{ $self->{resolved_depends} } ) {
        $_ = $_->( $self, $self->qr_params )
          if ( ref eq 'CODE' );
    }

    $self->{resolved_depends};
}

sub value_expires {
    my $self = shift;

    if (@_) {
        $self->{value_expires} = $_[0];
        return $self;
    }
    ( ref $self->{value_expires} eq 'CODE' ? $self->{value_expires}->( $self ) : $self->{value_expires} ) // 'never';
}

sub target_expires {
    my ( $self, $trg_obj ) = @_;

    $trg_obj->locked
        ?
        $self->{busy_lock} || $self->{cascade}{busy_lock} || 'never'
        :
        $trg_obj->expires // $trg_obj->expires( $self->value_expires );
}

sub ttl {
    my $self = shift;

    return undef
      unless exists $self->{ttl};

    $self->{ttl_time} && return $self->{ttl_time};

    if ( ref $self->{ttl} eq 'ARRAY' && @{ $self->{ttl} } == 2 ) {
        return $self->{ttl_time} = rand( $self->{ttl}[1] - $self->{ttl}[0] ) + $self->{ttl}[0];
    }
    elsif ( ref $self->{ttl} eq 'CODE' ) {
        return $self->{ttl_time} = $self->{ttl}->( $self, $self->qr_params );
    }

    return undef;
}

sub target      { shift->{matched_target} }
sub params      { shift->{params}         }
sub cascade     { shift->{cascade}        }
sub dep_values  { shift->{dep_values}     }
sub stash       { $_[0]->{run_instance} && $_[0]->{run_instance}{stash} || die "The run_instance is not defined!" }

1;
__END__

=head1 NAME

CHI::Cascade::Rule - a rule class

=head1 SYNOPSIS

    $cascade->rule(
        target  => qr/^target_(\d+)$/,
        depends => 'base_target',
        code    => sub {
            my ( $rule, $target, $dep_values ) = @_;

            # An execution of $cascade->run('target_12') will pass in code a $rule as:
            #
            # $rule->target     eq      $target
            # $rule->depends    ===     [ 'base_target' ]
            # $rule->qr_params  ===     ( 12 )
            # $rule->params     ==      [ 1, 2, 3 ]
        },
        params  => [ 1, 2, 3 ]
    );

    $cascade->run('target_12');

=head1 CONSTRUCTOR

An instance of this object is created by L<CHI::Cascade> in L<CHI::Cascade/rule>