callbacks results from the CPAN

scripts/generate_index.pl view on Meta::CPAN

						size: 12,
						weight: 'bold'
					}
				}
			}, tooltip: {
				callbacks: {
					label: function(context) {
						const raw = context.raw;
						const coverage = raw.y.toFixed(1);
						const delta = raw.delta?.toFixed(1) ?? '0.0';
						const sign = delta > 0 ? '+' : delta < 0 ? '-' : 'Â±';

view all matches for this distribution

CGI-MxScreen

8 results


#
# ->compute_screen
#
# Compute target screen, and run and enter/leave hooks if we change screens.
# This routine does not display anything, but runs all the action callbacks.
#
# Returns new screen object, and a ref to the argument list.
#
sub compute_screen {
	DFEATURE my $f_;


=item *

C<CGI::MxScreen> uses C<Carp::Datum> internally.  If you have chosen to
install a non-stripped version, you may trace parts of the module to better
understand what is going on with the various callbacks you register.

=back

=head2 Flow


 86 $manager->play();
 87 

This finally launches the state machine: the next state is computed, action
callbacks are fired, and the target screen is displayed.

=head2 More Readings

To learn about the interface of the C<CGI::MxScreen> manager object,
see L<"INTERFACE"> below.

=head1 SPECIFIC DATA TYPES

This sections documents in a central place the I<state> and I<callback>
representations that can be used throughout the C<CGI::MxScreen> framework.

Those specifications must be serializable, therefore all callbacks
are expressed in various symbolic forms, avoiding code references.

Do not forget that I<all> the arguments you specify in callbacks and screens
get serialized into the context.  Therefore, you must make sure your
objects are indeed serializable by the serializer (which is C<Storable>
by default, well, actually C<CGI::MxScreen::Serializer::Storable>, which is
wrapping the C<Storable> interface to something C<CGI::MxScreen> understands).
See L<CGI::MxScreen::Config> to learn how to change the

=head2 Utility Path

The concept of I<utility path> stems from the need to keep all callback
specification serializable.  Since C<Storable> cannot handle CODE references,
C<CGI::MxScreen> uses function names.  In some cases, we have a default
object to call the method on (e.g. during action callbacks), or one can
specify an object.  In some other case, a plain name must be used, and you
must tell C<CGI::MxScreen> in which packages it should look to find that name.

This is analogous to the PATH search done by the shell.  Unless you specify
an absolute path, the shell looks throughout your defined PATH directories,

etc...  That's what the utility path is.

The routine C<CGI::MxScreen::add_utils_path> must be used I<before> the
creation of the C<CGI::MxScreen> manager, and takes a list of strings,
which define the package namespaces to look through for field validation
callbacks and patching routines.  The reason it must be done I<before>
is that incoming CGI parameters are currently processed during the
manager's creation routine.

=head1 LOGGING

view all matches for this distribution

CGI-OptimalQuery

2 results

lib/CGI/OptimalQuery.pm view on Meta::CPAN


# format a value before it is executed in the database

=item B<< is_hidden => 1 >>

hides the select field and data from being viewed by the user. Data for this select is still available in callbacks and can be included in the hiddenFilter.

=item B<< always_select => 1 >>

tells OptimalQuery to always select the column regardless if it isn't explicitly being used in the show. This does not automatically make it shown to the user, but it will be available to the developer in callbacks.

=item B<< select_sql => (STRING | ARRAYREF) >>

=item B<< filter_sql => (STRING | ARRAYREF) >>

lib/CGI/OptimalQuery.pm view on Meta::CPAN


This is an advanced feature that can help perl guru's change the factory blueprints for optimal query modules instantiated by CGI::OptimalQuery.

=item B<< named_filters => { NORMAL_NAMED_FILTER, CUSTOM_NAMED_FILTER, .. } >>

allow developers to create complex predefined sql for insertion in the where clause by the 'filter' and 'hiddenFilter' parameters. There are two types of named_filters: "normal" and "custom". Normal named filters are defined with static SQL. Custom n...

=over

=item B<< NORMAL_NAMED_FILTER >>

lib/CGI/OptimalQuery.pm view on Meta::CPAN


=item B<< OQdataLCol => sub { } >>

=item B<< OQdataRCol => sub { } >>

Specify custom code to print the first or last column element. This is most often used to generate an view/edit button. If these callbacks are used, the editLink, and buildEditLink are ignored.

  OQdataLCol => sub {
    my ($rec) = @_; 
    return "<button onclick=\"OQopwin('/ViewRecord?id=$$rec{U_ID};on_update=OQrefresh';\">".
           "view</button>";

view all matches for this distribution

CGI-PrintWrapper

2 results

lib/CGI/PrintWrapper.pm view on Meta::CPAN

You could just call C<print> yourself on the appropriate file handle,
but there are many contexts in which it is cleaner to provide the
extra abstraction (such as mixing B<CGI> with B<HTML::Stream>, the
problem which prompted my solution, illustrated above).

B<CGI::PrintWrapper> creates the necessary callbacks for printing
dynamically, updating the symbol table as it encounters a new B<CGI>
method.

=head1 CONSTRUCTOR

view all matches for this distribution

CGI-Prototype

2 results

lib/CGI/Prototype.pm view on Meta::CPAN

behavior.  Slots can be added to add or alter behavior.  You can
subclass your subclasses when groups of your CGI pages share similar
behavior.  The possibilities are mind-boggling.

Within the templates, C<self> refers to the current controller.  Thus,
you can define callbacks trivially.  In your template, if you need some
data, you can pull it as a request:

  [% my_data = self.get_some_big_data %]

which is supplied by simply adding the same slot (method or data) in

view all matches for this distribution

CGI-Screen

2 results

lib/CGI/Screen.pm view on Meta::CPAN

C<last_screen> returns screen name and title in list context and
screen name in scalar context. Do not use the CGI parameters
C<screen_last_*> since they are changed before you can get hold of
them C<;-P>

=head2 The callbacks

All callbacks are called with three arguments: The query object, the
screen name and the screen title (= button/anchor text). Callbacks
should return a string.

=item C<application>

The C<application> method returns a string which is used
in the default C<title> and C<headline> callbacks. The Default method
returns the string C<"CGI::Screen Test"> and should definitely be
overwritten by your application.

=item C<title>

view all matches for this distribution

CGI-Snapp

7 results

	is       => 'rw',
	default  => sub{return ''},
	required => 0,
);

has _object_callbacks =>
(
	is       => 'rw',
	default  => sub{return {} },
	required => 0,
);

	is       => 'rw',
	default  => sub{return 'start'},
	required => 0,
);

my(%class_callbacks) =
(
	error          => {},
	forward_prerun => {},
	init           => {'CGI::Snapp' => ['cgiapp_init']},
	prerun         => {'CGI::Snapp' => ['cgiapp_prerun']},


	$hook = lc $hook;

	$self -> log(debug => "add_callback($hook, ...)");

	croak "Error: Unknown hook name '$hook'\n" if (! $class_callbacks{$hook});

	if (ref $self)
	{
		# it's an object-level callback.

		my($object_callback)     = $self -> _object_callbacks;
		$$object_callback{$hook} = [] if (! $$object_callback{$hook});

		push @{$$object_callback{$hook} }, $option;

		$self -> _object_callbacks($object_callback);
	}
	else
	{
		# It's a class-level callback.

		push @{$class_callbacks{$hook}{$self} }, $option;
	}

} # End of add_callback.

# --------------------------------------------------


	my(%seen);

	# Call object-level hooks.

	for my $callback (@{${$self -> _object_callbacks}{$hook} })
	{
		next if ($seen{$callback});

		try
		{


	# Call class-level hooks.

	for my $class (Class::ISA::self_and_super_path(ref $self || $self) )
	{
		next if (! exists $class_callbacks{$hook}{$class});

		for my $callback (@{$class_callbacks{$hook}{$class} })
		{
			next if ($seen{$callback});

			try
			{


} # End of _generate_output.

# --------------------------------------------------

sub get_callbacks
{
	my($self, $type, $hook) = @_;
	$type ||= '';
	$hook ||= '';

	$self -> log(debug => "get_callbacks($type, $hook)");

	croak "Error: \$type parameter to get_callbacks() must be 'class' or 'object'\n" if ($type !~ /^(?:class|object)$/);
	croak "Error: \$hook parameter to get_callbacks() must be a string\n"            if (length($hook) == 0);

	return $type eq 'class' ? $class_callbacks{$hook} : ${$self -> _object_callbacks}{$hook};

} # End of get_callbacks.

# --------------------------------------------------

sub get_current_runmode
{


	$hook = lc $hook;

	$self -> log(debug => "new_hook($hook)");

	$class_callbacks{$hook} ||= {};

	return 1;

}	# End of new_hook.


Aren't you glad that was the I<simple> view?

=head2 A More Complex View

L<CGI::Snapp> and before it L<CGI::Application> are designed in such a way that some of those methods are actually I<callbacks> aka I<hooks>, and their names are looked up via hook names.

See the Wikipedia article L<Hooking|http://en.wikipedia.org/wiki/Hooking> for a long explanation of hooks.

It works like this: A hook name is a key in a hash, and the corresponding value is a package name, which in turn points to an arrayref of method names. So, for a given hook name and
package, we can execute a series of named methods, where those names are listed in that arrayref.


An explanation:

=over 4

=item o Yes, there are class-level callbacks and object-level callbacks

See L</add_callback($hook, $option)> for details.

=item o The error hook


That name is either pre-defined (see L</new_hook($hook)>) or one of your own, which you've previously set up with L</new_hook($hook)>.

Sample code:

	# Class-level callbacks.
	$class_name -> add_callback('init', \&method_1);
	KillerApp   -> add_callback('init', 'method_2');

	# Object-level callbacks.
	$app = CGI::Snapp -> new;
	$app -> add_callback('init', \&method_3);

Notes:

=over 4

=item o Callback lifetimes

Class-level callbacks outlive the life of the $app object (of type L<CGI::Snapp> or your sub-class), by surviving for the duration of the Perl process, which, in a persistent
environment like L<Starman>, L<Plack>, etc, can be long enough to serve many HTTP client requests.

Object-level callbacks, however, go out of scope at the same time the $app object itself does.

=item o The class hierarchy

Callbacks can be registered by an object, or any of its parent classes, all the way up the hierarchy to L<CGI::Snapp>.

=item o Callback name resolution

Callback names are checked, and only the first with a given name is called. The type of callback, class or object, is ignored in this test, as it is in L<CGI::Application>.
This also means, that if there are 2 callbacks with the same name, in different classes, then still only the first is called.

Consider:

	In Class A: $self -> add_callback('teardown', 'teardown_sub');
	In Class B: $self -> add_callback('teardown', 'teardown_sub');


Only the pre-defined hooks are called by L<CGI::Snapp>. So, if you use your own name in calling new_hook($name), you are also responsible for triggering the calls to that hook.

The pre-defined hooks are called 'error', 'init', 'prerun', 'postrun' and 'teardown', and there is no need to call L</new_hook($hook)> for those.

=item o Class-level callbacks

These belong to the class of the object calling L</add_callback($hook, $option)>.

=item o Multiple callbacks for a given hook

If multiple I<class>-level callbacks are added for the same hook by different classes, they will be executed in reverse-class-hierarchy order.
That it, the callback for the most derived class is executed first. This is the way normal class-hierarchy overrides work - nothing unexpected here.

If multiple I<class>-level callbacks are added for the same hook by the same class, they will be executed in the order added, since they are pushed onto a stack (as are object-level
callbacks).

If multiple I<object>-level callbacks are added for the same hook, they are run in the order they are registered, i.e. in the order of calls to L</add_callback($hook, $option)>.

=item o The 'init' hook

Since the 'init' hook is triggered during the call to L</new()>, even before L</setup()> is called, there is no opportunity for normal end-user code (your sub-class of L<CGI::Snapp>) to attach
a callback to this hook.

Alternately, examine the source code of L<CGI::Snapp::Plugin::Forward> for another way to do things, although it uses 'forward_prerun' rather than 'init'.

=back

To summarize, you are I<strongly> advised to examine t/hook.test.pl and all the modules it uses to gain a deeper understanding of this complex issue. In particular, the order of 'use'
statements in your sub-class of L<CGI::Snapp> will determine the order in which class-level callbacks are triggered.

=head2 add_header(@headers)

Adds headers to the list which will be sent to the HTTP client.


=head2 call_hook($hook, @args)

Call the named hook. $hook is forced to be lower-case.

Returns a hashref of the number of callbacks actually called, where the keys are 'class' and 'object', and the values are integer counts.

@args takes various values, depending on the name of the callback:

=over 4


Deprecated.

See also L</add_header(@headers)>, L</delete_header(@keys)>, L</header_props([@headers])>, L</header_type([$option])> and L</How does add_header() differ from header_add()?>.

=head2 get_callbacks($type, $hook)

Gets callback information associated with the given $type (class/object) and $hook.

$type is 'class' for class-level callbacks, and 'object' for object-level callbacks.

Values for $type:

=over 4

=item o 'class'

get_callbacks('class', $hook) returns a I<hashref>.

The keys of this hashref are the class names which have registered callbacks for $hook.

The values of this hashref are arrayrefs of method names or references.

=item o 'object'

get_callbacks('object', $hook) returns an I<arrayref>.

The values of this arrayref are arrayrefs of method names or references.

=back


=head3 Always call croak and not a combination of croak and die

Also, every message passed to croak matches /^Error/ and ends with "\n".

=head3 No global variables (except for the inescapable dispatch table of class-level callbacks)

This means things like $$self{__CURRENT_RUNMODE} and $$self{__PRERUN_MODE_LOCKED} etc are only be available via method calls.

Here is a list of the global variables in L<CGI::Application>, and the corresponding methods in L<CGI::Snapp>, in alphabetical order:


=item o __HEADER_TYPE => L</header_type([$option])>

=item o __HTML_TMPL_CLASS => Not implemented

=item o __INSTALLED_CALLBACKS => L</installed_callbacks()>

=item o __IS_PSGI => _psgi()

=item o __MODE_PARAM => L</mode_param([@new_options])>


=over 4

=item o L</add_header(@headers)>

=item o L</get_callbacks($type, $hook)>

=item o L</log($level, $string)>

=item o L</logger($logger_object)>

view all matches for this distribution

CGI-Widget

1 match

Widget/HList.pm view on Meta::CPAN

CGI::Widget::HList::Node tree graph.  For more information, 
see L<CGI::Widget::HList::Node>.

This module is where image configurations, node rendering, 
and connector rendering methods are stored in the form of 
callbacks.

Check ex/ for example scripts

=head2 Constuctors

Widget/HList.pm view on Meta::CPAN

 root                        Root node of the tree to be rendered

 Images to be used in the HTML rendering of the tree:
 img_open,img_close,img_leaf,img_trunk,img_branch,img_corner,img_spacer                  

 The rendering methods themselves.  All are callbacks:
 render_node,render_branch,render_spacer,render_trunk                             

The rendering methods default to sensible code that uses the (also
default) images.  This can all be over-ridden.  See Methods.

view all matches for this distribution

CGI-XMLApplication

2 results

XMLApplication.pm view on Meta::CPAN


E.g. event_init handles the init event described below.

Each event has a single Parameter, the context. This can be an unblessed
hash reference or an object, where the user can store whatever needed.
This context is useful to pass scriptwide data between callbacks and
event functions around. The callback is even available and useable if
the script does not initialize the application context as earlier shown
in the program flow chart.

If such a function is not implemented in the application module,

XMLApplication.pm view on Meta::CPAN

=back

If errors occour on a certain stage of serialization, the application
is stopped and the generated error messages are returned.

CGI::XMLApplication provides four pseudo-callbacks, that are used to
get the application specific information during serialization. In
order of being called by CGI::XMLApplication::serialization() they
are:

=over 4

view all matches for this distribution

CHI-Cascade

1 match

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

created by this rule in notation described in L<CHI/"DURATION EXPRESSIONS">. The
B<default> is 'never'. It can be B<coderef> or B<string scalar> format as
L<CHI/"DURATION EXPRESSIONS">. A B<coderef> to be called as C<<
$coderef->($rule) >> and should return expire time as string value. You can use
this method inside L<CHI::Cascade/code> and L<CHI::Cascade/recomputed> your
callbacks if you want to force recomputing of current target through minimum
this time.

=back

=head1 AUTHOR

view all matches for this distribution

CLI-Gwrap

1 match

lib/CLI/Gwrapper/wxGrid.pm view on Meta::CPAN

    }

    return $grid;
}

# Button callbacks
sub onClick_Execute {
    my ($self, $button, $event) = @_;

    my @cmd_line = (
        $self->command->[0],    # the CLI command

view all matches for this distribution

CLI-Startup

1 match

Debian_CPANTS.txt view on Meta::CPAN

"libmarc-crosswalk-dublincore-perl", "MARC-Crosswalk-DublinCore", "0.02", "0", "0"
"libmarc-lint-perl", "MARC-Lint", "1.44", "0", "1"
"libmarc-perl", "MARC", "1.07", "0", "1"
"libmarc-record-perl", "MARC-Record", "2.0.3", "0", "0"
"libmarc-xml-perl", "MARC-XML", "0.92", "0", "0"
"libmasonx-interp-withcallbacks-perl", "MasonX-Interp-WithCallbacks", "1.18", "0", "0"
"libmath-algebra-symbols-perl", "Math-Algebra-Symbols", "1.21", "0", "1"
"libmath-base36-perl", "Math-Base36", "0.09", "0", "0"
"libmath-base85-perl", "Math-Base85", "0.2", "0", "0"
"libmath-basecalc-perl", "Math-BaseCalc", "1.016", "0", "0"
"libmath-basecnv-perl", "Math-BaseCnv", "1.8.B59BrZX", "0", "0"

view all matches for this distribution

CORBA-omniORB

1 match

pomni.h view on Meta::CPAN



//-------------------------------------------------------------------

/** Mutex to serialize servant calls from omniORB.  Allows the mutex
 * to be temporarily released to allow callbacks with a deeper
 * recursion level to execute.
 */

class POmniRatchetLock {
    omni_mutex mutex_;

view all matches for this distribution

CPAN-Changes

4 results

corpus/dists/IUP.changes view on Meta::CPAN


 - fixing broken links to examples

=head2 06/02/2013 - 0.100

 - updating callbacks newly added in iup 3.6/3.7
 - starting new version line

=head2 12/08/2012 - 0.006

 - attribute accesors now handled via AUTOLOAD

corpus/dists/IUP.changes view on Meta::CPAN

 - added: IUP::Canvas::(Palette|Pattern|Stipple|Bitmap) - canvas helper modules
 - added: IUP::Canvas::(InternalState|InternalServerImage|InternalContext) - canvas helper modules (hidden)
 - added: IUP::Canvas::FileBitmap
 - added: IUP::Canvas::FileVector - replacement for IUP::Canvas::(SVG|EMF)
 - added: IUP::ConfigData
 - fix for callbacks: better handling of callbacks with no return value (fallback to IUP_DEFAULT)
 - fix for callbacks: MULTITOUCH_CB, MULTISELECTION_CB, MULTIUNSELECTION_CB, NODEREMOVED_CB
 - removing debug stuff 'use Data::Dump(er)'

=head2 29/07/2011 - 0.002

 - removing invalid accessors "0" and "1"

view all matches for this distribution

CPAN-Common-Index

1 match

Todo view on Meta::CPAN

# Todo for CPAN::Common::Index

- base class needs support for logging callbacks: log_debug,
log_info, log_warn

view all matches for this distribution

CPAN-Maker

1 match

lib/File/Process.pm view on Meta::CPAN


=back

=head1 CAVEATS

Processing each line using hooks and callbacks can introduce
inefficiencies in file processing. This class is meant to be used on
moderately sized files. In it's basic forms, the methods will read all
lines into memory as it iterates over the file. Your processing may
not require that lines be accumulated at all. Your custom C<process()>
or C<filter()> hook can choose to return an undefined value which

view all matches for this distribution

CPAN-Meta-YAML

1 match

t/README.md view on Meta::CPAN

Test::More::subtest that is reasonably compatible back to 0.88.  If using
subtests, you must not set a plan in the subtest and you must use
done_testing in the *.t file.

The TestML::Tiny library contains functions for parsing and executing TestML
tests with callbacks.  TestML is a data-driven testing language; TestML::Tiny
implements a small subset of its features. See the section on TestML, below,
for an example. Generally, bugs should be patched upstream on CPAN and then
a new Test::Tiny CPAN release can be copied here and pod-stripped.

The TestBridge library contains testing functions for use in .t files or to
be passed to TestML::Tiny functions as callbacks.  Test functions should not
include `done_testing`.  They should use `subtest` for any repetitive testing
that loops over test cases.  Callback should check for the expected test
points (see below) and skip a TML block if those points are not available.

The TestUtils library contains utility functions.  Testing functions should

view all matches for this distribution

CPAN-MetaCurator

2 results

data/tiddlers.json view on Meta::CPAN

        "modified": "20251016231649084",
        "created": "20230612012815961"
    },
    {
        "created": "20231009225516915",
        "text": "\"\"\"\no See also:\n- AiEngines\n- AlgorithmicStuff - For retry mechanisms\n- ArchiveFiles\n- ChildProcesses\n- DatabaseAndSQL - For Async::Redis, DBD::PgAsync etc\n- DataTraversal - For CSV handling\n- DatesAndTimes\n- DnsStuff\n- ...
        "title": "EventStuff",
        "modified": "20260404212244763"
    },
    {
        "created": "20220308004358235",

data/tiddlers.json view on Meta::CPAN

        "title": "PerlDocumentation",
        "modified": "20260220013145977",
        "created": "20210920080620336"
    },
    {
        "text": "\"\"\"\no See also:\n- CpanFile\n- MarlinStuff\n- ModuleBuilding\n- TestingHelp\n- https://lists.perl.org/all.html - For Perl Mailing Lists - Alphabetical\n- https://metacpan.org/pod/CPAN::Porters\n- https://www.nntp.perl.org/group/p...
        "title": "PerlInternals",
        "modified": "20260326220735265",
        "created": "20250629024631868"
    },
    {

view all matches for this distribution

CPAN-Testers-WWW-Blog

5 results

vhost/html/js/tiny_mce/plugins/fullscreen/fullscreen.htm view on Meta::CPAN


		// Override options for fullscreen
		for (var n in paSe.fullscreen_settings)
			settings[n] = paSe.fullscreen_settings[n];

		// Patch callbacks, make them point to window.opener
		patchCallback(settings, 'urlconverter_callback');
		patchCallback(settings, 'insertlink_callback');
		patchCallback(settings, 'insertimage_callback');
		patchCallback(settings, 'setupcontent_callback');
		patchCallback(settings, 'save_callback');

view all matches for this distribution

CPAN-Testers-WWW-Reports

5 results

vhost/html/js/tiny_mce/plugins/fullscreen/fullscreen.htm view on Meta::CPAN


		// Override options for fullscreen
		for (var n in paSe.fullscreen_settings)
			settings[n] = paSe.fullscreen_settings[n];

		// Patch callbacks, make them point to window.opener
		patchCallback(settings, 'urlconverter_callback');
		patchCallback(settings, 'insertlink_callback');
		patchCallback(settings, 'insertimage_callback');
		patchCallback(settings, 'setupcontent_callback');
		patchCallback(settings, 'save_callback');

view all matches for this distribution

CPAN-Testers-WWW-Wiki

5 results

vhost/html/js/tiny_mce/plugins/fullscreen/fullscreen.htm view on Meta::CPAN


		// Override options for fullscreen
		for (var n in paSe.fullscreen_settings)
			settings[n] = paSe.fullscreen_settings[n];

		// Patch callbacks, make them point to window.opener
		patchCallback(settings, 'urlconverter_callback');
		patchCallback(settings, 'insertlink_callback');
		patchCallback(settings, 'insertimage_callback');
		patchCallback(settings, 'setupcontent_callback');
		patchCallback(settings, 'save_callback');

view all matches for this distribution

CPAN-Visitor

2 results

lib/CPAN/Visitor.pm view on Meta::CPAN

# Arguments:
#
#   jobs -- if greater than 1, distributions are processed in parallel
#           via Parallel::ForkManager
#
# iterate() takes several optional callbacks which are run in the following
# order.  Callbacks get a single hashref argument as described above under
# default actions.
#
#   check -- whether the distribution should be processed; goes to next file
#            if false; default is always true

lib/CPAN/Visitor.pm view on Meta::CPAN

C<result>   â€” an empty hashref to start; the return values from each action are added and may be referenced by subsequent actions

=back

The C<result> field is used to accumulate the return values from action
callbacks.  For example, the return value from the default 'extract' action is
the unpacked distribution directory:

  $job->{result}{extract} # distribution directory path

You do not need to store the results yourself â€” the C<iterate> method
takes care of it for you.

Callbacks occur in the following order.  Some callbacks skip further
processing if the return value is false.

=over 4

=item *

view all matches for this distribution

CPAN-cpanminus-reporter-RetainReports

1 match

t/02-constants.t ..... ok
t/09-load-threads.t .. skipped: This perl wasn't built to support threads
t/10-simple.t ........ ok
t/11-multiple.t ...... ok
t/13-data.t .......... ok
t/14-callbacks.t ..... ok
# According to Config::Perl::V version 0.29, this is NOT a debugging perl
# Not testing global destruction
t/15-self.t .......... ok
# Using Hash::Util::FieldHash 1.20
t/16-huf.t ........... ok

t/zvg_51dbm_file.t 
t/zvg_52dbm_complex.t 
t/zvg_53sqlengine_adv.t 
t/zvg_60preparse.t 
t/zvg_65transact.t 
t/zvg_70callbacks.t 
t/zvg_72childhandles.t 
t/zvg_73cachedkids.t 
t/zvg_80proxy.t 
t/zvg_85gofer.t 
t/zvg_86gofer_fail.t

t/zvp_51dbm_file.t 
t/zvp_52dbm_complex.t 
t/zvp_53sqlengine_adv.t 
t/zvp_60preparse.t 
t/zvp_65transact.t 
t/zvp_70callbacks.t 
t/zvp_72childhandles.t 
t/zvp_73cachedkids.t 
t/zvp_80proxy.t 
t/zvp_85gofer.t 
t/zvp_86gofer_fail.t

t/zvxgp_51dbm_file.t 
t/zvxgp_52dbm_complex.t 
t/zvxgp_53sqlengine_adv.t 
t/zvxgp_60preparse.t 
t/zvxgp_65transact.t 
t/zvxgp_70callbacks.t 
t/zvxgp_72childhandles.t 
t/zvxgp_73cachedkids.t 
t/zvxgp_80proxy.t 
t/zvxgp_85gofer.t 
t/zvxgp_86gofer_fail.t

t/51dbm_file.t .................. ok
t/52dbm_complex.t ............... skipped: DBI::SQL::Nano is being used
t/53sqlengine_adv.t ............. ok
t/60preparse.t .................. ok
t/65transact.t .................. ok
t/70callbacks.t ................. ok
t/72childhandles.t .............. ok
t/73cachedkids.t ................ ok
t/80proxy.t ..................... skipped: modules required for proxy are probably not installed (e.g., RPC/PlClient.pm)
t/85gofer.t ..................... ok
t/86gofer_fail.t ................ ok

t/zvg_51dbm_file.t .............. ok
t/zvg_52dbm_complex.t ........... skipped: DBI::SQL::Nano is being used
t/zvg_53sqlengine_adv.t ......... skipped: Modifying driver state won't compute running behind Gofer
t/zvg_60preparse.t .............. ok
t/zvg_65transact.t .............. skipped: Transactions not supported by DBD::Gofer
t/zvg_70callbacks.t ............. ok
t/zvg_72childhandles.t .......... ok
t/zvg_73cachedkids.t ............ ok
t/zvg_80proxy.t ................. skipped: modules required for proxy are probably not installed (e.g., RPC/PlClient.pm)
t/zvg_85gofer.t ................. ok
t/zvg_86gofer_fail.t ............ skipped: Gofer DBI_AUTOPROXY

t/zvp_51dbm_file.t .............. ok
t/zvp_52dbm_complex.t ........... skipped: DBI::SQL::Nano is being used
t/zvp_53sqlengine_adv.t ......... ok
t/zvp_60preparse.t .............. skipped: preparse not supported for DBI::PurePerl
t/zvp_65transact.t .............. ok
t/zvp_70callbacks.t ............. skipped: $h->{Callbacks} attribute not supported for DBI::PurePerl
t/zvp_72childhandles.t .......... ok
t/zvp_73cachedkids.t ............ ok
t/zvp_80proxy.t ................. skipped: modules required for proxy are probably not installed (e.g., RPC/PlClient.pm)
t/zvp_85gofer.t ................. ok
t/zvp_86gofer_fail.t ............ skipped: requires Callbacks which are not supported with PurePerl

t/zvxgp_51dbm_file.t ............ ok
t/zvxgp_52dbm_complex.t ......... skipped: DBI::SQL::Nano is being used
t/zvxgp_53sqlengine_adv.t ....... skipped: Modifying driver state won't compute running behind Gofer
t/zvxgp_60preparse.t ............ skipped: preparse not supported for DBI::PurePerl
t/zvxgp_65transact.t ............ skipped: Transactions not supported by DBD::Gofer
t/zvxgp_70callbacks.t ........... skipped: $h->{Callbacks} attribute not supported for DBI::PurePerl
t/zvxgp_72childhandles.t ........ ok
t/zvxgp_73cachedkids.t .......... ok
t/zvxgp_80proxy.t ............... skipped: modules required for proxy are probably not installed (e.g., RPC/PlClient.pm)
t/zvxgp_85gofer.t ............... ok
t/zvxgp_86gofer_fail.t .......... skipped: requires Callbacks which are not supported with PurePerl

view all matches for this distribution

CPANPLUS-Dist-Build

2 results

lib/CPANPLUS/Dist/Build.pm view on Meta::CPAN

    ### fit. The default installed callback will return the hashref in
    ### an unmodified form
    ### this callback got added after cpanplus 0.0562, so use a 'can'
    ### to find out if it's supported. For older versions, we'll just
    ### return the hashref as is ourselves.
    my $href    = $cb->_callbacks->can('filter_prereqs')
                    ? $cb->_callbacks->filter_prereqs->( $cb, $prereqs )
                    : $prereqs;

    $self->status->prereqs( $href );

    ### make sure it's not the same ref

lib/CPANPLUS/Dist/Build.pm view on Meta::CPAN


                ### mark specifically *test* failure.. so we don't
                ### send success on force...
                $test_fail++;

                if( !$force and !$cb->_callbacks->proceed_on_test_failure->(
                                      $self, $@ )
                ) {
                    $dist->status->test(0);
                    if ( $conf->get_conf('cpantest') ) {
                      $status->{stage} = 'test';

view all matches for this distribution

CPANPLUS-Dist-Deb

1 match

lib/CPANPLUS/Dist/Deb.pm view on Meta::CPAN


        ### run the contents through the callback for munging
        ### make this conditional, as this was introduced in the
        ### dev branch of 0.81_01, so not all may have it (automatically)
        ### installed
        if( $cb->_callbacks->munge_dist_metafile ) {
            $contents = $cb->_callbacks->munge_dist_metafile->( 
                            $cb, $contents 
                        );
        }                        

        $fh->print( $contents );

view all matches for this distribution

CPANPLUS-Dist-Fedora

1 match

lib/CPANPLUS/Dist/Fedora.pm view on Meta::CPAN

            # ... FIXME
        },
        $status->specpath,
    );

    if ( $intern->_callbacks->munge_dist_metafile ) {
        print 'munging...';

        my $orig_contents = _read_file( $status->specpath );
        my $new_contents = $intern->_callbacks->munge_dist_metafile->($intern, $orig_contents);
        _write_file( $status->specpath, $new_contents );
    }

    # copy package.
    my $tarball = "$dir/" . basename $module->status->fetch;

view all matches for this distribution

CPANPLUS-Internals-Source-CPANIDX

1 match

lib/CPANPLUS/Internals/Source/CPANIDX/HTTP.pm view on Meta::CPAN

  $res = $http->request($url, \&savetofile, OUT);
  close OUT;

=item set_callback ( $functionref, $dataref )

At various stages of the request, callbacks may be used to modify the
behaviour or to monitor the status of the request.  These work like the
$data_callback parameter to request(), but are more verstaile.  Using
set_callback disables $data_callback in request()

The callbacks are called as: 
  callback ( $self, $phase, $dataref, $cbargs )

The current phases are:

  connect - connection has been established and headers are being

view all matches for this distribution

CPANPLUS-Internals-Source-CPANMetaDB

1 match

lib/CPANPLUS/Internals/Source/CPANMetaDB/HTTP.pm view on Meta::CPAN

  $res = $http->request($url, \&savetofile, OUT);
  close OUT;

=item set_callback ( $functionref, $dataref )

At various stages of the request, callbacks may be used to modify the
behaviour or to monitor the status of the request.  These work like the
$data_callback parameter to request(), but are more verstaile.  Using
set_callback disables $data_callback in request()

The callbacks are called as: 
  callback ( $self, $phase, $dataref, $cbargs )

The current phases are:

  connect - connection has been established and headers are being

view all matches for this distribution

CPANPLUS

13 results