view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

	}
	close FH or die "close($_[0]): $!";
}
END_OLD

# _version is for processing module versions (eg, 1.03_05) not
# Perl versions (eg, 5.8.1).
sub _version ($) {
	my $s = shift || 0;
	my $d =()= $s =~ /(\.)/g;
	if ( $d >= 2 ) {

 view release on metacpan or  search on metacpan

Makefile  view on Meta::CPAN

	  lib/Acme/WTF.pm $(INST_MAN3DIR)/Acme::WTF.$(MAN3EXT) 




# --- MakeMaker processPL section:


# --- MakeMaker installbin section:

 view release on metacpan or  search on metacpan

lib/Win32/PEPM.pm  view on Meta::CPAN

a .pm that can be C<do>, C<require>d, or C<use>d, and the same .pm is a 100%
real DLL containing XS code. The generated file meets the file format standards
of both a .pm and a PE (Portable Executable) DLL and uses no temp files.
The author of this module sees this module as a joke since with this
"packager", the .pm text is stored uncompressed in the .dll, and there is no
sane reason to keep .pm text memory mapped into a process since after
parsing/compiling .pm, the .pm text is never referenced again, yet with this
"packager", if the XS DLL is loaded, so is the .pm text, into the process.

The resulting .pm that is built can not be edited even though it mostly looks
like plain text. If it is edited, the DLL will be corrupt. The resulting .pm,
although superficially looking like pure perl can not be moved between perl
installations/versions except for maint versions, since the XS DLL inside the

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

	}
	close FH or die "close($_[0]): $!";
}
END_OLD

# _version is for processing module versions (eg, 1.03_05) not
# Perl versions (eg, 5.8.1).
sub _version ($) {
	my $s = shift || 0;
	my $d =()= $s =~ /(\.)/g;
	if ( $d >= 2 ) {

 view release on metacpan or  search on metacpan

lib/Acme/YAPC/Okinawa/ppport.h  view on Meta::CPAN

pregfree2||5.011000|
pregfree|||
prescan_version||5.011004|
printbuf|||
printf_nocontext|||vn
process_special_blocks|||
ptr_hash|||n
ptr_table_clear||5.009005|
ptr_table_fetch||5.009005|
ptr_table_find|||n
ptr_table_free||5.009005|

 view release on metacpan or  search on metacpan

lib/Acme/constant.pm  view on Meta::CPAN

As the Perl compiler needs to know about which barewords are keywords,
constants have to defined in C<BEGIN> section. Usually, this is not a
problem, as C<use> statement is automatically put in implicit C<BEGIN>
section, but that also means you cannot dynamically create constants.
For example, in the example below, the C<DEBUG> constant is always
created, with value 1, as C<use> is processed when Perl parser sees
it.

    if ($ENV{DEBUG}) {
        use Acme::constant DEBUG => 1; # WRONG!
    }

 view release on metacpan or  search on metacpan

inc/Module/Install/Win32.pm  view on Meta::CPAN

Please download the file manually, save it to a directory in %PATH% (e.g.
C:\WINDOWS\COMMAND\), then launch the MS-DOS command line shell, "cd" to
that directory, and run "Nmake15.exe" from there; that will create the
'nmake.exe' file needed by this module.

You may then resume the installation process described in README.

-------------------------------------------------------------------------------
END_MESSAGE
	}
}

 view release on metacpan or  search on metacpan

lib/Acrux/DBI/Dump.pm  view on Meta::CPAN

=head2 dbi

    $dump = $dump->dbi($dbi);
    my $dbi = $dump->dbi;

The object these processing belong to

=head2 name

    my $name = $dump->name;
    $dump = $dump->name('foo');

lib/Acrux/DBI/Dump.pm  view on Meta::CPAN

    my $tag = TAG_DEFAULT;
    my $delimiter = DELIMITER;
    my $is_new = 1;
    my $buf = '';

    # String processing
    while (length($s)) {
        my $chunk;

        # get fragments (chunks) from string
        if ($s =~ /^$delimiter/x) { # any delimiter char(s)

 view release on metacpan or  search on metacpan

lib/Acrux/Digest.pm  view on Meta::CPAN

=head2 data

    my $data = $provider->data;
    $provider = $provider->data({foo => 'bar'});

Data structure to be processed

=head1 METHODS

This class implements the following methods

 view release on metacpan or  search on metacpan

bin/activator.pl  view on Meta::CPAN

    # last arg, hence the flag after undef below
    $config = Activator::Config->get_config( \@ARGV, undef, 1 );
};

if ( catch my $e ) {
    die( "Error while processing command line options: $e" );
}

my $log_level = $config->{log_level} || 'WARN';
if ( $config->{v} || $config->{verbose} ) {
    Activator::Log->level( 'INFO' );

bin/activator.pl  view on Meta::CPAN

    foreach $cmd ( @cmds ) {
	DEBUG( $cmd );
	die "$cmd failed" unless !system( $cmd );
    }

    # TODO: abstract this out such that we can process any number of
    # configured directories. Since this is running under the apache
    # engine, we know to process the share/apache/ config.
    #
    # TODO: make activator_codebase NOT be required: When activator
    # installs, it should look for the share directory.
    #
    find( \&process, "$config->{activator_codebase}/share/apache2" );


    # process configuration files

    my $config_files = $config->{sync_config_files};

    my $reg = Activator::Registry->new();
    foreach my $config_file ( @$config_files ) {
	DEBUG( "processing config file: $config_file");
	my $fq_source_file = "$config->{conf_path}/$config_file";
	my $fq_dest_file   ="$config->{sync_conf_dir}/$config_file";

	if ( $config_file =~ /\.ya?ml$/i ) {

bin/activator.pl  view on Meta::CPAN

		YAML::Syck::DumpFile( $fq_dest_file,
				      # get realm returns a hashref
				      $reg->get_realm( $config_file ) );
	    };
	    if ( catch my $e ) {
		WARN( "Couldn't process YAML file '$config_file': $e");
	    }
	}

	# if it's a template process it based on the current config.
	elsif ($config_file =~ /\.tt$/i ) {
	    $config_file =~ /(.+)\.tt$/;
	    my $out = $1;
	    if ( !$out ) {
		WARN( "Couldn't process Template file '$config_file'");
		next;
	    }
#	    $fq_dest_file = "$config->{sync_conf_dir}/$out";
	    my $tt = Template->new( { DEBUG => 1,
				      ABSOLUTE => 1,
				      OUTPUT_PATH  => $config->{sync_conf_dir},
				    }
				  );
	    DEBUG( qq(tt processing: $fq_source_file, $config, $out ));
	    $tt->process( $fq_source_file, $config, $out ) || Activator::Log->logdie( $tt->error()."\n");
	}

	# just copy the file
	else {
	    my $rsync_flags = ( $config->{debug} ? '-v' : '' );

bin/activator.pl  view on Meta::CPAN

    DEBUG("...with command: $cmd");
    system( $cmd );

}

# TODO: this should process anything, not just apache2 files
sub process {
    my $dir  = $File::Find::dir; # is the current directory name,
    my $file = $_;               # is the current filename within that directory
    my $fq   = $File::Find::name; # is the complete pathname to the file.

    # capture the intervening path
    $fq =~ m|share/apache2/(.+)\.tt$|;
    my $out = $1;
    return unless $out;

    DEBUG( qq( processing $file into ).$config->{apache2}->{ServerRoot}.'/'.$out );
    my $tt = Template->new( { DEBUG => 1,
			      ABSOLUTE => 1,
			      OUTPUT_PATH  => $config->{apache2}->{ServerRoot},
			    }
			  );
    $tt->process( $fq, $config, $out ) || Activator::Log->logdie( $tt->error()."\n");

    # TODO: use some smart hueristics to properly chmod that which
    # should be executable
    #
    #if( $out =~ m@/s?bin/|/init.d/@ ) {

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

		print FH $_[$_] or die "print($_[0]): $!";
	}
	close FH or die "close($_[0]): $!";
}

# _version is for processing module versions (eg, 1.03_05) not
# Perl versions (eg, 5.8.1).
sub _version ($) {
	my $s = shift || 0;
	my $d =()= $s =~ /(\.)/g;
	if ( $d >= 2 ) {

 view release on metacpan or  search on metacpan

lib/Activiti/Rest/Client.pm  view on Meta::CPAN

  my $client = Activiti::Rest::Client->new(
    url => 'http://kermit:kermit@localhost:8080/activiti-rest/service'
  );

  my $res = $client->process_definitions;

  die("no parsed content") unless $res->has_parsed_content;

  my $pdefs = $res->parsed_content;

  my @ids = map { $_->{id} } @{ $pdefs->{data} };
  for my $id(@ids){
    print Dumper($client->process_definition(processDefinitionId => $id)->parsed_content);
  }

=head1 CONSTRUCTOR parameters

=head2 url

lib/Activiti/Rest/Client.pm  view on Meta::CPAN

    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_definitions

  List of process definitions

  parameters: see user guide (http://www.activiti.org/userguide/index.html#N13520)

  equal to rest call:

    GET repository/process-definitions

=cut

sub process_definitions {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/repository/process-definitions",
    params => \%args,
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_definition

  Get a process definition

  parameters:

    processDefinitionId

  other parameters: see user guide (http://www.activiti.org/userguide/index.html#N13605)

  equal to rest call:

    GET repository/process-definitions/:processDefinitionId

=cut

sub process_definition {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/repository/process-definitions/".uri_escape($args{processDefinitionId}),
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_definition_resource_data

  Get a process definition resource content

  parameters:

    processDefinitionId

  equal to rest call:

    GET repository/process-definitions/:processDefinitionId/resourcedata

=cut

sub process_definition_resource_data {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/repository/process-definitions/".uri_escape($args{processDefinitionId})."/resourcedata",
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}

=head2 process_definition_model

  Get a process definition BPMN model

  parameters:

    processDefinitionId

  equal to rest call:

    GET repository/process-definitions/:processDefinitionId/model

=cut

sub process_definition_model {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/repository/process-definitions/".uri_escape($args{processDefinitionId})."/model",
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_definition_identity_links

  Get all candidate starters for a process-definition

  parameters:

    processDefinitionId

  equal to rest call:

    GET repository/process-definitions/:processDefinitionId/identitylinks

=cut
sub process_definition_identity_links {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/repository/process-definitions/".uri_escape($args{processDefinitionId})."/identitylinks",
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_definition_identity_link

  Get a candidate starter from a process definition

  parameters: (see http://www.activiti.org/userguide/index.html#N138A9)

    processDefinitionId
    family
    identityId

  equal to rest call:

    GET repository/process-definitions/:processDefinitionId/identitylinks/:family/:identityId

=cut
sub process_definition_identity_link {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/repository/process-definitions/".uri_escape($args{processDefinitionId})."/identitylinks/".uri_escape($args{family})."/".uri_escape($args{identityId}),
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}

lib/Activiti/Rest/Client.pm  view on Meta::CPAN

    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_instances

  List of process instances

  Parameters: see user guide (http://www.activiti.org/userguide/index.html#restProcessInstancesGet)

  equal to rest call:

    GET runtime/process-instances

=cut

sub process_instances {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances",
    params => \%args,
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_instance

  Get a process instance

  Parameters:

    processInstanceId

  equal to rest call:

    GET runtime/process-instances/:processInstanceId

=cut

sub process_instance {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances/".uri_escape($args{processInstanceId}),
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
sub delete_process_instance {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances/".uri_escape($args{processInstanceId}),
    params => { deleteReason => $args{deleteReason} },
    method => "DELETE"
  );
  Activiti::Rest::Response->from_http_response($res);
}
sub suspend_process_instance {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances/".uri_escape($args{processInstanceId}),
    params => {},
    headers => {
      'Content-Type' => "application/json",
      Content => encode_json({ action => "suspend" })
    },
    method => "PUT"
  );
  Activiti::Rest::Response->from_http_response($res);
}
sub activate_process_instance {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances/".uri_escape($args{processInstanceId}),
    params => {},
    headers => {
      'Content-Type' => "application/json",
      Content => encode_json({ action => "activate" })
    },
    method => "PUT"
  );
  Activiti::Rest::Response->from_http_response($res);
}

=head2 query_process_instances

  Query process instances

  Parameters: see user guide (http://www.activiti.org/userguide/index.html#N13E2A)

  equal to rest call:

    POST runtime/process-instances

=cut

sub query_process_instances {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/query/process-instances",
    params => {},
    method => "POST",
    headers => {
      'Content-Type' => "application/json",
      Content => encode_json($args{content})
    }
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 start_process_instance

  Start a process instance

  Parameters: see user guide (http://www.activiti.org/userguide/index.html#N13CE6)

  equal to rest call:

    POST runtime/process-instances

=cut

sub start_process_instance {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances",
    params => {},
    method => "POST",
    headers => {
      'Content-Type' => "application/json",
      Content => encode_json($args{content})
    }
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_instance_identitylinks

  Get involved people for process instance

  Parameters:

    processInstanceId

  equal to rest call:

    GET runtime/process-instances/:processInstanceId/identitylinks

=cut

sub process_instance_identitylinks {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances/".uri_escape($args{processInstanceId})."/identitylinks",
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_instance_variables

  List of variables for a process instance

  Parameters:

    processInstanceId

  equal to rest call:

    GET runtime/process-instances/:processInstanceId/variables

=cut

sub process_instance_variables {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances/".uri_escape($args{processInstanceId})."/variables",
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_instance_variable

  Get a variable for a process instance

  Parameters:

    processInstanceId
    variableName

  equal to rest call:

    GET runtime/process-instances/:processInstanceId/variables/:variableName

=cut

sub process_instance_variable {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances/".uri_escape($args{processInstanceId})."/variables/".uri_escape($args{variableName}),
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
sub update_process_instance_variable {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances/".uri_escape($args{processInstanceId})."/variables/".uri_escape($args{variableName}),
    params => {},
    method => "PUT",
    headers => {
      'Content-Type' => "application/json",
      Content => encode_json($args{content})
    }
  );
  Activiti::Rest::Response->from_http_response($res);
}
#DEPRECATED!
sub signal_process_instance {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/process-instance/".uri_escape($args{processInstanceId})."/signal",
    params => {},
    method => "POST",
    headers => {
      'Content-Type' => "application/json",
      Content => encode_json($args{content})
    }
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 process_instance_diagram

  Get a diagram for a process instance

  Parameters:

    processInstanceId

  equal to rest call:

    GET runtime/process-instances/:processInstanceId/diagram

  when successfull the "content_type" of the response is "image/png" and "content" is equal to the image data

=cut

#return: png image data
sub process_instance_diagram {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/runtime/process-instances/".uri_escape($args{processInstanceId})."/diagram",
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}

lib/Activiti/Rest/Client.pm  view on Meta::CPAN

    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 historic_process_instances

  List of historic process instances

  Parameters: see user guide (http://www.activiti.org/userguide/index.html#restHistoricProcessInstancesGet)

  equal to rest call:

    GET history/historic-process-instances

=cut

sub historic_process_instances {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/history/historic-process-instances",
    params => \%args,
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 query_historic_process_instances

  Query for historic process instances

  Parameters: see user guide (http://www.activiti.org/userguide/index.html#N153C2)

  equal to rest call:

    POST history/historic-process-instances

=cut
sub query_historic_process_instances {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/query/historic-process-instances",
    params => {},
    method => "POST",
    headers => {
      'Content-Type' => "application/json",
      Content => encode_json($args{content})
    }
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 historic_process_instance

  Get a historic process instance

  Parameters:

    processInstanceId

  equal to rest call:

    GET history/historic-process-instances/:processInstanceId

=cut

sub historic_process_instance {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/history/historic-process-instances/".uri_escape($args{processInstanceId}),
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 delete_historic_process_instance

  Delete a historic process instance

  Parameters:

    processInstanceId

  equal to rest call:

    DELETE history/historic-process-instances/:processInstanceId

=cut

sub delete_historic_process_instance {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/history/historic-process-instances/".uri_escape($args{processInstanceId}),
    params => {},
    method => "DELETE"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 historic_process_instance_comments

  Get all comments on a historic process instance

  Parameters:

    processInstanceId

  equal to rest call:

    GET history/historic-process-instances/:processInstanceId/comments

=cut

sub historic_process_instance_comments {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/history/historic-process-instances/".uri_escape($args{processInstanceId})."/comments",
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 historic_process_instance_comment

  Get a comment on a historic process instance

  Parameters:

    processInstanceId
    commentId

  equal to rest call:

    GET history/historic-process-instances/:processInstanceId/comments/:commentId

=cut

sub historic_process_instance_comment {
  my($self,%args)=@_;
  my $res = $self->ua->request(
    path => "/history/historic-process-instances/".uri_escape($args{processInstanceId})."/comments/".uri_escape($args{commentId}),
    params => {},
    method => "GET"
  );
  Activiti::Rest::Response->from_http_response($res);
}

lib/Activiti/Rest/Client.pm  view on Meta::CPAN

  );
  Activiti::Rest::Response->from_http_response($res);
}
=head2 historic_variable_instances

  Get historic variable instances, either from tasks or process instances

  Parameters: see user guide (http://www.activiti.org/userguide/index.html#restHistoricVariableInstancesGet)

  equal to rest call:

lib/Activiti/Rest/Client.pm  view on Meta::CPAN

    );
    Activiti::Rest::Response->from_http_response($res);
}
=head2 query_historic_variable_instances

  Query historic variable instances, either from tasks or process instances

  Parameters: see user guide (http://www.activiti.org/userguide/index.html#N15B00)

  equal to rest call:

 view release on metacpan or  search on metacpan

ex/ai-bot.pl  view on Meta::CPAN

#   IRC_NICKNAME=Bert           Bot nickname (default: random from a fun list)
#   OWNER=Getty                 Bot owner name for personality (default: $USER)
#   IRC_CHANNELS=#ai            Channels to join
#   DB_FILE=ai-bot.db           SQLite database path
#   MAX_LINE_LENGTH=400         Max IRC line length (default: 400)
#   BUFFER_DELAY=1.5            Seconds to buffer messages before processing (default: 1.5)
#   LINE_DELAY=1.5              Delay between outgoing IRC lines (default: 1.5)
#   IDLE_PING=1800              Seconds of silence before idle ping (default: 1800)
#   SYSTEM_PROMPT=...           Additional text appended to the system prompt

use strict;

ex/ai-bot.pl  view on Meta::CPAN

);
has _buffer_timers => (
  is => 'rw', traits => ['NoGetopt'],
  default => sub { {} },  # { channel => alarm_id }
);
has _processing => (
  is => 'rw', traits => ['NoGetopt'],
  default => 0,
);
has _pending_raid => (
  is => 'rw', traits => ['NoGetopt'],

ex/ai-bot.pl  view on Meta::CPAN

  push @{$self->_msg_buffer->{$channel} ||= []}, { channel => $channel, nick => $nick, msg => $msg };
  # Per-channel timer: cancel previous, set new
  if (my $id = delete $self->_buffer_timers->{$channel}) {
    POE::Kernel->alarm_remove($id);
  }
  my $id = POE::Kernel->alarm_set( _process_buffer => time() + $BUFFER_DELAY, $channel );
  $self->_buffer_timers->{$channel} = $id;
}

event _process_buffer => sub {
  my ($self, $channel) = @_[OBJECT, ARG0];
  delete $self->_buffer_timers->{$channel};

  return if $self->_processing;
  my @messages = @{$self->_msg_buffer->{$channel} || []};
  return unless @messages;

  $self->_msg_buffer->{$channel} = [];
  $self->_processing(1);

  # Auto-recall: gather notes about active nicks
  my %seen_nicks;
  for my $m (@messages) {
    next if $m->{nick} eq 'system';

ex/ai-bot.pl  view on Meta::CPAN

sub _schedule_pending_buffers {
  my ($self) = @_;
  for my $ch (keys %{$self->_msg_buffer}) {
    next unless @{$self->_msg_buffer->{$ch} || []};
    next if $self->_buffer_timers->{$ch};  # already scheduled
    my $id = POE::Kernel->alarm_set( _process_buffer => time() + $BUFFER_DELAY, $ch );
    $self->_buffer_timers->{$ch} = $id;
  }
}

my @BRAINFREEZE = (

ex/ai-bot.pl  view on Meta::CPAN

  if ($@) {
    $self->error("Raider error: $@");
    # Show error only in main channel
    $self->_send_to_channel($self->_default_channel,
      "Something broke in my brain. Getty probably forgot to feed the hamster that powers my GPU.");
    $self->_processing(0);
    $self->_schedule_pending_buffers;
    return;
  }

  # Log rate limit info

ex/ai-bot.pl  view on Meta::CPAN

      $self->info(sprintf "Rate limit: %s requests remaining, %s tokens remaining",
        $rl->requests_remaining // '?', $rl->tokens_remaining // '?');
    }
  };

  $self->_processing(0);

  # Check for silence
  if ($answer =~ /__SILENT__/) {
    $self->info("Bert chose to stay silent");
    $self->_schedule_pending_buffers;

ex/ai-bot.pl  view on Meta::CPAN

};

event _idle_check => sub {
  my ($self) = $_[OBJECT];
  my $idle_secs = time() - $self->_last_activity;
  if ($idle_secs >= $IDLE_PING && !$self->_processing) {
    my $idle_mins = int($idle_secs / 60);
    $self->info("Idle ping after ${idle_mins}m");
    # Ping first channel only (idle is a global concept)
    my $channel = $self->_default_channel;
    $self->_buffer_message($channel, 'system',

 view release on metacpan or  search on metacpan

lib/AddressBook/DB/PDB.pm  view on Meta::CPAN

	$self->_add_category($value);
      }
      $record->{category}=$self->{category_hash}->{$value};
    } elsif (exists $self->{phone_labels}->{$field}) {
      push @phone_attrs, $field;
      next; #defer phone field processing until later
    } else {
      $record->{entry}->[$labels{$field}] = $value;
    }
  }
  # now process phone fields
  foreach $field (sort {$attrs->{$a}->{meta}->{order} <=> $attrs->{$b}->{meta}->{order}} @phone_attrs) {
    # for the time being, we will concatenate like phone fields
    $value = join $self->{intra_attr_sep_char}, @{$attrs->{$field}->{value}};
    $record->{phoneLabel}->[$phone_index] = $self->{phone_labels}->{$field};
    $record->{entry}->[$phone_index+3] = $value;

lib/AddressBook/DB/PDB.pm  view on Meta::CPAN

unset are timestamped with "0" (very, very old).

=head1 Deleted Records

PDB records which have the "deleted" flag set are removed as part of the initialization
process.  The "archive" flag is ignored. 

=head1 Categories

For convienience, a record's category is treated like any other attribute.  New
categories are created as necessary.  Moving a record to a new category will achieve

 view release on metacpan or  search on metacpan

lib/Ado/Build.pm  view on Meta::CPAN

use ExtUtils::Installed;
use ExtUtils::Install;
use parent 'Module::Build';
use Exporter qw( import );    #export functionality to Ado::BuildPlugin etc..
our @EXPORT_OK = qw(
  create_build_script process_etc_files do_create_readme
  process_public_files process_templates_files
  ACTION_perltidy ACTION_submit PERL_DIRS);

sub PERL_DIRS {
    state $dirs = [map { catdir($_[0]->base_dir, $_) } qw(bin lib etc t)];
    return @$dirs;

lib/Ado/Build.pm  view on Meta::CPAN

        $self->install_path($be => catdir($prefix, $be));
    }
    return $self->SUPER::create_build_script();
}

sub process_public_files {
    my $self = shift;
    for my $asset (@{$self->rscan_dir('public')}) {
        if (-d $asset) {
            make_path(catdir('blib', $asset));
            next;

lib/Ado/Build.pm  view on Meta::CPAN

        copy($asset, catfile('blib', $asset));
    }
    return;
}

sub process_etc_files {
    my $self   = shift;
    my $prefix = $self->install_base || $self->config('siteprefix');
    my $mode   = $ENV{MOJO_MODE} ||= 'development';

    for my $asset (@{$self->rscan_dir('etc')}) {

lib/Ado/Build.pm  view on Meta::CPAN

        copy($asset, catfile('blib', $asset));
    }
    return;
}

sub process_log_files {
    my $self = shift;
    for my $asset (@{$self->rscan_dir('log')}) {
        if (-d $asset) {
            make_path(catdir('blib', $asset));
            next;

lib/Ado/Build.pm  view on Meta::CPAN

        copy($asset, catfile('blib', $asset));
    }
    return;
}

sub process_templates_files {
    my $self = shift;
    for my $asset (@{$self->rscan_dir('templates')}) {
        if (-d $asset) {
            make_path(catdir('blib', $asset));
            next;

lib/Ado/Build.pm  view on Meta::CPAN

sub ACTION_test {
    my $self = shift;

    #Custom functionality before test
    $self->_process_custom_files(catdir('blib', 'etc'), catdir('blib', 'log'))
      if -d 'blib';
    $self->_process_custom_files('etc', 'log');
    $self->SUPER::ACTION_test;
    return;
}

sub ACTION_dist {

lib/Ado/Build.pm  view on Meta::CPAN

    #TODO: Think about what to do with *.conf and *.sqlite files in case of upgrade!!!
    #TODO: (upgrade)rotate logs - archive existing log files before emptying.
    $self->SUPER::ACTION_install;

    #Custom functionality after installation
    $self->_process_custom_files($self->install_path('etc'), $self->install_path('log'));
    return;
}

sub _process_custom_files {
    my ($self, $etc_dir, $log_dir) = @_;

    #make some files writable and/or readable only by the user that runs the application
    my $ro = oct('0400');
    my $rw = oct('0600');

lib/Ado/Build.pm  view on Meta::CPAN

=head1 DESCRIPTION

This is a subclass of L<Module::Build>. We use L<Module::Build::API> to add
custom functionality. This module and L<Ado::BuildPlugin> exist just because of
the additional install paths that we use beside C<lib> and C<bin> and
processing the files in those paths. These modules also can serve as examples
for your own builders if you have some custom things to do during  build, test,
install and even if you need to add a new C<ACTION_*> to your setup.

=head1 ATTRIBUTES

lib/Ado/Build.pm  view on Meta::CPAN

In this method we also call C<add_build_element> for C<etc> C<public>,
C<templates> and C<log> folders.
Finally we set all the C<install_path>s for the distro
and we call C<$self-E<gt>SUPER::create_build_script>.

=head2 process_etc_files

Moves files found in C<Ado/etc> to C<Ado/blib/etc>.
See L<Module::Build::API/METHODS>
Returns void.

=head2 process_log_files

Moves files found in C<Ado/log> to C<Ado/blib/log>.
Returns void.

=head2 process_public_files

Moves files found in C<Ado/public> to C<Ado/blib/public>.
Returns void.

=head2 process_templates_files

Moves files found in C<Ado/templates> to C<Ado/blib/templates>.
Returns void.

=head2 ACTION_build

 view release on metacpan or  search on metacpan

Config.pm  view on Meta::CPAN

   eval {
      $begin_special_vars{PPID} = getppid ();
   };
   if ( $@ ) {
      DBUG_PRINT ("INFO", "Cheating to get the PPID.  It may be wrong!");
      # We can't easily get the parent process id for Windows.
      # So we're going to cheat a bit.  We'll ask if any parent
      # or grandparent process used this module before and call it
      # the parent process!
      $secret_tag = "_ADVANCED_CONFIG_PPID_";

      if ( $ENV{$secret_tag} ) {
         $begin_special_vars{PPID} = $ENV{$secret_tag};
      } else {

 view release on metacpan or  search on metacpan

Infix2Postfix.pm  view on Meta::CPAN

  die "error stack is: @_ error\n";
}

# Preloaded methods go here.

# Autoload methods go after =cut, and are processed by the autosplit program.

1;
__END__
# Below is the stub of documentation for your module. You better edit it!

 view release on metacpan or  search on metacpan

builder/Affix/Builder.pm  view on Meta::CPAN

        my @dirs;
        push @dirs, '../';
        my $has_cxx = !1;
        my @sources = $cwd->child('lib/Affix.c');

        #~ warn "Sources to process: @sources\n";
        for my $source (@sources) {

            #~ warn "Processing source: $source\n";
            my $cxx       = $source =~ /cx+$/;
            my $file_base = $source->basename(qr[.c$]);

 view release on metacpan or  search on metacpan

lib/Agent/TCLI/Package/Net/HTTP.pm  view on Meta::CPAN

  handler: establish_context
  help: http web cient environment
  manual: >
    Currently the http commands available only support limited capabilities.
    One can request a url and verify that a desired response code was
    received, but HTML content is not processed.
  topic: net
  usage: http tget url=http:\example.com\request resp=404
---
Agent::TCLI::Command:
  name: tget

 view release on metacpan or  search on metacpan

bin/agent_tail.pl  view on Meta::CPAN

     'jid'		=> Net::XMPP::JID->new($username.'@'.$domain.'/'.$resource),
     'jserver'	=> $host,
	 'jpassword'=> $password,
	 'peers'	=> \@users,

	 'xmpp_process_time'=> 1,

     'verbose'    => \$verbose,        # Verbose sets level or warnings

     'control_options'	=> {
	     'packages' 		=> \@packages,

 view release on metacpan or  search on metacpan

examples/keepalive.pl  view on Meta::CPAN

print "S: writing 'hi there!\\n' to C...\n";
print $client "hi there! Ed!\n";
print "S: done.\n";
undef $client;	# terminate socket connection

"Waiting for process $pid...\n";
waitpid( $pid, 0 );

 view release on metacpan or  search on metacpan

lib/Aion/Annotation.pm  view on Meta::CPAN

=encoding utf-8

=head1 NAME

Aion::Annotation - processes annotations in perl modules

=head1 VERSION

0.0.3

 view release on metacpan or  search on metacpan

lib/Aion/Emitter.pm  view on Meta::CPAN

This event dispatcher implements the B<Event Dispatcher> pattern in which an event is defined by the class of the event object (event).

The listener is registered as an aeon in the pleroma and will always be represented by one object.

The event processing method is marked with the C<#@listen> annotation.

=head1 SUBROUTINES

=head2 emit ($event, [$key])

 view release on metacpan or  search on metacpan

lib/Aion/Fs.pm  view on Meta::CPAN

=item * L<File::Find::Iterator> – has an OOP interface with an iterator and the C<imap> and C<igrep> functions.

=item * L<File::Find::Match> – calls a handler for each matching filter. Similar to C<switch>.

=item * L<File::Find::Node> – traverses the file hierarchy in parallel by several processes: C<< tie @paths, IPC::Shareable, { key =E<gt> "GLUE STRING", create =E<gt> 1 }; File::Find::Node-E<gt>new(".")-E<gt>process(sub { my $f = shift; $f-E<gt>for...

=item * L<File::Find::Fast> – C<@paths = @{ find($dir) }>.

=item * L<File::Find::Object> – has an OOP interface with an iterator.

lib/Aion/Fs.pm  view on Meta::CPAN

=item * L<File::Find::Rule> – C<< @files = File::Find::Rule-E<gt>any( File::Find::Rule-E<gt>file-E<gt>name('*.mp3', '*.ogg')-E<gt>size('E<gt>2M'), File::Find::Rule-E<gt>empty )-E<gt>in($dir1, $dir2); >>. Has an iterator, procedural interface and ex...

=item * L<File::Find::Wanted> – C<@paths = find_wanted( sub { -f && /\.png/ }, $dir )>.

=item * L<File::Hotfolder> – C<< watch( $dir, callback =E<gt> sub { push @paths, shift } )-E<gt>loop >>. Powered by C<AnyEvent>. Customizable. There is parallelization into several processes.

=item * L<File::Mirror> – also forms a parallel path for copying files: C<recursive { my ($src, $dst) = @_; push @paths, $src } '/path/A', '/path/B'>.

=item * L<File::Set> – C<< $fs = File::Set-E<gt>new; $fs-E<gt>add($dir); @paths = map { $_-E<gt>[0] } $fs-E<gt>get_path_list >>.

 view release on metacpan or  search on metacpan

lib/Aion/Query.pm  view on Meta::CPAN

Creates an additional connection to the base and kills the main one.

To do this, use C<$Aion::Query::base_connection_id>.

SQLite runs in the same process, so C<$Aion::Query::base_connection_id> has C<-1>. That is, for SQLite this method does nothing.

	my @x = query_stop;
	\@x  # --> []

=head2 sql_debug ($fn, $query)

 view release on metacpan or  search on metacpan

lib/Aion/Spirit.pm  view on Meta::CPAN

=encoding utf-8

=head1 NAME

Aion::Spirit - functions for controlling the program execution process

=head1 VERSION

0.0.1

 view release on metacpan or  search on metacpan

lib/Akamai/Open/Client.pm  view on Meta::CPAN

 my $req = Akamai::Open::DiagnosticTools->new(client => $client);

=head1 ABOUT

I<Akamai::Open::Client> provides the data structure which holds the 
client specific data which is needed for the authentication process 
against the I<Akamai::Open> API.

This data is provided by Akamai and can be found in your 
L<LUNA control center account|https://control.akamai.com/>, 
inside the I<Manage APIs> tool.

 view release on metacpan or  search on metacpan

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN

    $self->{agent} = Akamai::Edgegrid->new(
        config_file => $args{config_file} || "$ENV{HOME}/.edgerc",
        section     => $args{section} || "default"
    );
    $self->{max_processes} = $args{max_processes} || 4;

    return $self;
}

sub retrieve_property_data {
    my ($self) = @_;
    my $agent = $self->{agent};
    my $pm = Parallel::ForkManager->new($self->{max_processes});

    # 基本URL
    my $baseurl = "https://" . $agent->{host};

# Endpoint to retrieve contract IDs

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN

            # Retrieve property information
            my $properties_data = decode_json($properties_resp->decoded_content);
            my $properties = $properties_data->{properties}->{items};

            foreach my $property (@$properties) {
                # Fork a new process for each property
                $pm->start and next;

                my $property_id = $property->{propertyId};
                my $property_name = $property->{propertyName};

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN

                    }
                } else {
                    warn "Error retrieving activation information ($property_name): " . $activations_resp->status_line . " - Skipping\n";
                }
                
                # End the child process
                $pm->finish;
            }
        } elsif ($properties_resp->code == 403 || $properties_resp->code == 404) {
            warn "Error retrieving property list (Contract ID: $contract_id, Group ID: $group_id): " . $properties_resp->status_line . " - Skipping\n";
        } else {

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN

    use Akamai::PropertyFetcher;

    my $fetcher = Akamai::PropertyFetcher->new(
        config_file   => "$ENV{HOME}/.edgerc",
        max_processes => 4
    );
    $fetcher->retrieve_property_data();

=head1 DESCRIPTION

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN

=item * config_file

.edgercファイルのパス。デフォルトはC<$ENV{HOME}/.edgerc>。

=item * max_processes

並列プロセスの最大数。デフォルトは4。

=back

 view release on metacpan or  search on metacpan

lib/Album/Tutorial.pm  view on Meta::CPAN

  (No index pages needed updating)

'album' tries to avoid doing unnecessary work as much as possible. In
this case, all thumbnails and image and index pages are up to date.
The line of periods shows progress, one period for each image
processed.

=head2 Protecting your work

'album' not only tries to avoid doing unnecessary work, but it is also
very careful to not destroy your original images, nor any other

lib/Album/Tutorial.pm  view on Meta::CPAN

=back

Environment variable ALBUMCONFIG can be used to designate user
config files. It should be set to a colon-separated list of file names
to be processed in order of precedence.

=head2 Importing new images

An important feature of 'album' is importing new images from an
external source. For example, you can import new images from a CD-ROM,

lib/Album/Tutorial.pm  view on Meta::CPAN

  (Needed to write 18 image pages)
  Creating pages for 1 index
  (Needed to write 1 index page)

Two new images were found on the CD-ROM, copied to the 'large'
directory, and processed as usual. 'info.dat' has been updated with
the new entries. Note that images found on the CD-ROM that already
exist in 'large' (i.e., have the same name) are skipped.

=head2 Using EXIF information

lib/Album/Tutorial.pm  view on Meta::CPAN

while copying the image, it will be rotated if necessary,
according to the 'orientation' property in the EXIF information.

=back

To enable EXIF processing, add the B<--exif> command line option, or
specify the import directory with B<--dcim> instead of B<--import>:

  $ ls -l /mnt/camera/dcim/101msdcf
  -rwxr-xr-x 1 jv jv 2347808 Jun 25 12:08 /mnt/camera/dcim/101msdcf/dsc00052.jpg
  -rwxr-xr-x 1 jv jv 1327475 Jun 25 12:05 /mnt/camera/dcim/101msdcf/dsc00053.jpg

 view release on metacpan or  search on metacpan

lib/Algorithm/AM.pm  view on Meta::CPAN

                'No prediction possible.');
        }
        return;
    }

    $result->_process_stats(
        # TODO: after refactoring to a "guts" object,
        # just pass that in
        $self->{sum},
        $self->{pointers},
        $self->{itemcontextchainhead},