password results from the CPAN

config.pl view on Meta::CPAN


# Channels to join on OFTC
@oftc_channels = ();

# Password to identify to NickServ with
$oftc_nickserv_password = 'asd';

# BitlBee
# =======

# Comment this out to disable the BitlBee plugin

config.pl view on Meta::CPAN

$bitlbee_server = 'localhost';

# BitlBee server port
$bitlbee_port = 6667;

# BitlBee server password
$bitlbee_password = 'parola';

# Common
# ======

# Directory to store state in

view all matches for this distribution

App-Framework

4 results

examples/eg-sql.pl view on Meta::CPAN

	# Set up database access
	$app->sql(
			'database'	=> $opts{'database'},
			'table'		=> $opts{'table'},
			'user'		=> $opts{'user'},
			'password'	=> $opts{'password'},
			
			# Option to do some Sql debugging by tracing transactions to a file
			'trace'		=> $opts{'debug'} ? 4 : 0,
			'trace_file'=> 'logsql.log',
			'debug' => $opts{'debug'},

examples/eg-sql.pl view on Meta::CPAN


-user=s User

Your MySql user

-password=s	Pass

Your MySql password


__#=============================================================================================================================
__DATA__ listings2.sql

view all matches for this distribution

App-GHGen

1 match

lib/App/GHGen/Generator.pm view on Meta::CPAN


      - name: Log in to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'

      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5

view all matches for this distribution

App-GHPT

1 match

lib/App/GHPT/WorkSubmitter/Role/Question.pm view on Meta::CPAN

    package App::GHPT::WorkSubitter::Question::WarnAboutPasswordFile;
    use App::GHPT::Wrapper::OurMoose;
    with 'App::GHPT::WorkSubmitter::Role::Question';

    sub ask($self) {
        # skip the question unless there's a password file
        return unless $self->changed_files->changed_files_match(qr/password/);

        # ask the user if that's okay
        return $self->ask_question(<<'ENDOFTEXT',"I'm okay with the risk");
    You've committed a file with a name matching 'password'.  Are you nuts?
    ENDOFTEXT
    }

    __PACKAGE__->meta->make_immutable;
    1;

view all matches for this distribution

App-GUI-Cellgraph

1 match

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-GUI-Harmonograph

1 match

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-GUI-Juliagraph

1 match

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-GenPericmdCompleterScript

1 match

script/gen-pericmd-completer view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--no-config>, B<-C>

Do not use any configuration file.

view all matches for this distribution

App-Genpass-ID

7 results

lib/App/Genpass/ID.pm view on Meta::CPAN


our %SPEC;

$SPEC{genpass} = {
    v => 1.1,
    summary => 'Generate password from combination of Indonesian words',
    description => $App::Genpass::WordList::SPEC{genpass}{description},
    args => {
        num => {
            schema => ['int*', min=>1],
            default => 1,

lib/App/Genpass/ID.pm view on Meta::CPAN

        wordlists => ['ID::KBBI'],
    );
}

1;
# ABSTRACT: Generate password from combination of Indonesian words

__END__

=pod

=encoding UTF-8

=head1 NAME

App::Genpass::ID - Generate password from combination of Indonesian words

=head1 VERSION

This document describes version 0.003 of App::Genpass::ID (from Perl distribution App-Genpass-ID), released on 2018-01-02.

lib/App/Genpass/ID.pm view on Meta::CPAN


Usage:

 genpass(%args) -> [status, msg, result, meta]

Generate password from combination of Indonesian words.

Using password from dictionary words (in this case, from WordList::*) can be
useful for humans when remembering the password. Note that using a string of
random characters is generally better because of the larger space (combination).
Using a password of two random words from a 5000-word wordlist has a space of
only ~25 million while an 8-character of random uppercase letters/lowercase
letters/numbers has a space of 62^8 = ~218 trillion. To increase the space
you'll need to use more words (e.g. 3 to 5 instead of just 2). This is important
if you are using the password for something that can be bruteforced quickly e.g.
for protecting on-disk ZIP/GnuPG file and the attacker has access to your file.
It is then recommended to use a high number of rounds for hashing to slow down
password cracking (e.g. C<--s2k-count 65011712> in GnuPG).

This function is not exported.

Arguments ('*' denotes required arguments):

view all matches for this distribution

App-Genpass-WordList

7 results

lib/App/Genpass/WordList.pm view on Meta::CPAN

    $pattern;
}

$SPEC{genpass} = {
    v => 1.1,
    summary => 'Generate password with words from WordList::*',
    description => <<'_',

Using password from dictionary words (in this case, from WordList::*) can be
useful for humans when remembering the password. Note that using a string of
random characters is generally better because of the larger space (combination).
Using a password of two random words from a 5000-word wordlist has a space of
only ~25 million while an 8-character of random uppercase letters/lowercase
letters/numbers has a space of 62^8 = ~218 trillion. To increase the space
you'll need to use more words (e.g. 3 to 5 instead of just 2). This is important
if you are using the password for something that can be bruteforced quickly e.g.
for protecting on-disk ZIP/GnuPG file and the attacker has access to your file.
It is then recommended to use a high number of rounds for hashing to slow down
password cracking (e.g. `--s2k-count 65011712` in GnuPG).

_
    args => {
        num => {
            schema => ['int*', min=>1],

lib/App/Genpass/WordList.pm view on Meta::CPAN

    );
    return $res unless $res->[0] == 200;

    my @words = shuffle @{ $res->[2] };

    my @passwords;
    for my $i (1..$num) {
        push @passwords,
            _fill_pattern($patterns->[rand @$patterns], \@words);
    }

    [200, "OK", \@passwords];
}

1;
# ABSTRACT: Generate password with words from WordList::*

__END__

=pod

=encoding UTF-8

=head1 NAME

App::Genpass::WordList - Generate password with words from WordList::*

=head1 VERSION

This document describes version 0.002 of App::Genpass::WordList (from Perl distribution App-Genpass-WordList), released on 2018-01-02.

lib/App/Genpass/WordList.pm view on Meta::CPAN


Usage:

 genpass(%args) -> [status, msg, result, meta]

Generate password with words from WordList::*.

Using password from dictionary words (in this case, from WordList::*) can be
useful for humans when remembering the password. Note that using a string of
random characters is generally better because of the larger space (combination).
Using a password of two random words from a 5000-word wordlist has a space of
only ~25 million while an 8-character of random uppercase letters/lowercase
letters/numbers has a space of 62^8 = ~218 trillion. To increase the space
you'll need to use more words (e.g. 3 to 5 instead of just 2). This is important
if you are using the password for something that can be bruteforced quickly e.g.
for protecting on-disk ZIP/GnuPG file and the attacker has access to your file.
It is then recommended to use a high number of rounds for hashing to slow down
password cracking (e.g. C<--s2k-count 65011712> in GnuPG).

This function is not exported.

Arguments ('*' denotes required arguments):

view all matches for this distribution

App-Genpass

11 results

package App::Genpass;
# ABSTRACT: Quickly and easily create secure passwords
$App::Genpass::VERSION = '2.401';
use Carp;
use Moo;
use Sub::Quote 'quote_sub';
use MooX::Types::MooseLike::Base qw/Int Str Bool ArrayRef/;

sub generate {
    my ( $self, $number ) = @_;

    my $length;
    my $verify        = $self->verify;
    my @passwords     = ();
    my @verifications = ();
    my $EMPTY         = q{};

    my ( $char_types, @chars ) = @{ $self->_get_chars };


    if ( (defined($self->length) && $num_of_types > $self->length)
         || ($num_of_types > $self->minlength) ) {
        $length = defined($self->length) ? $self->length : $self->minlength.' minimum';
        croak <<"_DIE_MSG";
You wanted a shorter password that the variety of characters you've selected.
You requested $num_of_types types of characters but only have $length length.
_DIE_MSG
    }

    if ($self->minlength > $self->maxlength) {

    $length = $self->length
            || $self->minlength + int(_rand(abs($self->maxlength - $self->minlength) + 1));

    $number ||= $self->number;

    # each password iteration needed
    foreach my $pass_iter ( 1 .. $number ) {
        my $password  = $EMPTY;
        my $char_type = shift @char_types;

        # generating the password
        while ( $length > length $password ) {
            my $char = $chars[ int _rand @chars ];

            # for verifying, we just check that it has small capital letters
            # if that doesn't work, we keep asking it to get a new random one
            # the check if it has large capital letters and so on


                $char_type =
                    scalar @char_types > 0 ? shift @char_types : $EMPTY;
            }

            $password .= $char;
        }

        # since the verification process creates a situation of ordered types
        # (lowercase, uppercase, numerical, special)
        # we need to shuffle the string
        $password = join $EMPTY, shuffle( split //sm, $password );

        $number == 1 && return $password;

        push @passwords, $password;

        @char_types = @{$char_types};
    }

    return wantarray ? @passwords : \@passwords;
}


1;


=encoding UTF-8

=head1 NAME

App::Genpass - Quickly and easily create secure passwords

=head1 VERSION

version 2.401

    $genpass = App::Genpass->new( readable => 0, length => 20 );
    print "$_\n" for $genpass->generate(10);

=head1 DESCRIPTION

If you've ever needed to create 10 (or even 10,000) passwords on the fly with
varying preferences (lowercase, uppercase, no confusing characters, special
characters, minimum length, etc.), you know it can become a pretty pesky task.

This module makes it possible to create flexible and secure passwords, quickly
and easily.

    use App::Genpass;
    my $genpass = App::Genpass->new();

    my $single_password    = $genpass->generate(1);  # returns scalar
    my @single_password    = $genpass->generate(1);  # returns array
    my @multiple_passwords = $genpass->generate(10); # returns array again
    my $multiple_passwords = $genpass->generate(10); # returns arrayref

This distribution includes a program called B<genpass>, which is a command line
interface to this module. If you need a program that generates passwords, use
B<genpass>.

=for stopwords boolean DWIM DWYM arrayref perldoc Github CPAN's AnnoCPAN CPAN

=head1 SUBROUTINES/METHODS


=over 4

=item number

You can decide how many passwords to create. The default is 1.

This can be overridden per I<generate> so you can have a default of 30 but in a
specific case only generate 2, if that's what you want.

=item readable

Default: on.

=item verify

Verify that every type of character wanted (lowercase, uppercase, numerical,
specials, etc.) are present in the password. This makes it just a tad slower,
but it guarantees the result. Best keep it on.

To emphasize how "slower" it is: if you create 500 passwords of 500 character
length, using C<verify> off, will make it faster by 0.1 seconds.

Default: on.

=back


=over 4

=item minlength

The minimum length of password to generate.

Default: 8.

=item maxlength

The maximum length of password to generate.

Default: 10.

=item length

Use this if you want to explicitly specify the length of password to generate.

=back

=head3 character attributes


=back

=head2 generate

This method generates the password or passwords.

It accepts an optional parameter indicating how many passwords to generate.

    $gp = App::Genpass->new();
    my @passwords = $gp->generate(300); # 300 passwords to go

If you do not provide a parameter, it will use the default number of passwords
to generate, defined by the attribute B<number> explained above.

This method tries to be tricky and DWIM (or rather, DWYM). That is, if you
request it to generate only one password and use scalar context
(C<< my $p = $gp->generate(1) >>), it will return a single password.

However, if you try to generate multiple passwords and use scalar context
(C<< my $p = $gp->generate(30) >>), it will return an array reference for the
passwords.

Generating passwords with list context (C<< my @p = $gp->generate(...) >>)
will always return a list of the passwords, even if it's a single password.

=head2 get_config_from_file

Reads the configuration file using L<Config::Any>.

view all matches for this distribution

App-GeoCancerPrognosticDatasetsRetriever

1 match

bin/geoCancerPrognosticDatasetsRetriever view on Meta::CPAN

		#check if current system is Ubuntu/or Ubuntu-based
		my $ubuntu = qx{uname -a};
			
		if ($ubuntu=~ /.+ubuntu.+/ig) {
			
			print color ("red"), "curl binary was not found: follow onscreen instructions/input your password for its installation...\n\n", color("reset");
			system("sudo apt -y install curl"); #install curl
			print "done\n";	
		} 
			
		else {

view all matches for this distribution

App-Gimei

1 match

Dockerfile view on Meta::CPAN

            git curl \
            libreadline-dev libssl-dev zlib1g-dev &&\
    apt-get -y clean &&\
    rm -rf /var/lib/apt/lists/*

RUN adduser --disabled-password --gecos '' user
RUN echo 'user ALL=(root) NOPASSWD:ALL' > /etc/sudoers.d/user

USER user
WORKDIR /home/user

view all matches for this distribution

App-Git-IssueManager

1 match

LICENSE.txt view on Meta::CPAN

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-Git-Workflow

3 results

lib/App/Git/Workflow/Command/Feature.pm view on Meta::CPAN

        'branch|b=s',
        'local|l!',
        'pom|x=s',
        'url|u=s',
        'user|U=s',
        'pass|password|P=s',
        'jira|j=s',
        'fetch|f!',
        'new_pom|new-pom|n!',
        'push|p',
    ) or return;

lib/App/Git/Workflow/Command/Feature.pm view on Meta::CPAN

  -j --jira[=]JIRAID
                    Find the summary for JIRA item JIRAID and make it the
                    branch name for the feature.
  -u --url[=]URL    Use URL as the JIRA instance for looking up summaries.
  -U --user[=]str   JIRA user name to use when querying JIRA
  -P --password[=]str
                    JIRA password for --user
  -t --tag[=]str    Specify a tag that any branch with newer commits must contain
  -b --branch[=]str Similarly a branch that other branches with newer commits must
                    contain (Default origin/master)
  -l --local        Shorthand for --branch '^master$'
  -p --push         Push the new brach upstream

view all matches for this distribution

App-GitGerrit

2 results

lib/App/GitGerrit.pm view on Meta::CPAN

        return (undef, undef);
    }
}

sub credential_description_file {
    my ($baseurl, $password) = @_;

    my %credential = (
        protocol => $baseurl->scheme,
        host     => $baseurl->host,
        path     => $baseurl->path,
        password => $password,
    );

    # Try to get the username from the baseurl
    my ($username) = url_userinfo($baseurl);
    $credential{username} = $username if $username;

lib/App/GitGerrit.pm view on Meta::CPAN

        # means that we're using a pre-1.8 Git, which doesn't
        # support git-credential yet.
        $git_credential_supported = 0;
    }

    my ($username, $password) = @credentials{qw/username password/};

    unless (defined $username && defined $password) {
        debug "Get credentials from git-gerrit.baseurl";
        ($username, $password) = url_userinfo(config('baseurl'));
    }

    unless (defined $username && defined $password) {
        debug "Get credentials from a .netrc file";
        if (eval {require Net::Netrc}) {
            if (my $mach = Net::Netrc->lookup(URI->new(config('baseurl'))->host, $username)) {
                ($username, $password) = ($mach->login, $mach->password);
            }
        } else {
            debug "Failed to require Net::Netrc";
        }
    }

    unless (defined $username && defined $password) {
        debug "Prompt the user for the credentials";
        if (eval {require Term::Prompt}) {
            $username = Term::Prompt::prompt('x', 'Gerrit username: ', '', $ENV{USER});
            $password = Term::Prompt::prompt('p', 'Gerrit password: ', '');
            print "\n";
        } else {
            debug "Failed to require Term::Prompt";
        }
    }

    defined $username or error "Couldn't get credential's username";
    defined $password or error "Couldn't get credential's password";

    return ($username, $password);
}

sub set_credentials {
    my ($username, $password, $what) = @_;

    return 1 unless $git_credential_supported;

    $what =~ /^(?:approve|reject)$/
        or error "set_credentials \$what argument ($what) must be either 'approve' or 'reject'";

    my $baseurl = URI->new(config('baseurl'));
    my ($fh, $credfile) = credential_description_file($baseurl, $password);

    return system("git credential $what <$credfile") == 0;
}

# The get_message routine returns the message argument to the

lib/App/GitGerrit.pm view on Meta::CPAN

sub gerrit {
    my $method = shift;

    state $gerrit;
    unless ($gerrit) {
        my ($username, $password) = get_credentials;
        require Gerrit::REST;
        $gerrit = Gerrit::REST->new(config('baseurl'), $username, $password);
        eval { $gerrit->GET("/projects/" . uri_escape_utf8(config('project'))) };
        if (my $error = $@) {
            set_credentials($username, $password, 'reject') if $error->{code} == 401;
            die $error;
        } else {
            set_credentials($username, $password, 'approve');
        }
    }

    if ($Options{debug}) {
        my ($endpoint, @args) = @_;

view all matches for this distribution

App-GitGot

3 results

lib/App/GitGot/Command/fork.pm view on Meta::CPAN

  }
  elsif ( defined $config{pass} and defined $config{user} ) {
    return ( login => $config{user} , pass => $config{pass} )
  }
  else {
    say STDERR "Couldn't parse password or access_token info from ~/.github-identity"
      and exit(1);
  }
}

sub _parse_github_url {

view all matches for this distribution

App-GitHooks-Plugin-PgBouncerAuthSyntax

2 results

lib/App/GitHooks/Plugin/PgBouncerAuthSyntax.pm view on Meta::CPAN

				}
			);
			next;
		}

		# Skip lines with the correct username/password specification.
		next
			if $line =~ /
					^
					"[^"]*"   # Username.
					\         # Space.

view all matches for this distribution

App-GitHooks-Plugin-PreventTrailingWhitespace

1 match

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-GitHooks-Plugin-RubyCompile

1 match

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-GitHub

2 results

lib/App/GitHub.pm view on Meta::CPAN

sub set_login {
    my ( $self, $login ) = @_;

    ( $login, my $pass ) = split( /\s+/, $login, 2 );
    unless ( $login and $pass ) {
        $self->print("Wrong login args ($login $pass), eg fayland password");
        return;
    }

    $self->_do_login( $login, $pass );
}

view all matches for this distribution

App-GitHubPullRequest

1 match

  list [<state>]    Show all pull requests (state: open/closed)
  show <number>     Show details for the specified pull request
  patch <number>    Fetch a properly formatted patch for specified pull request
  checkout <number> Create tracking branch for specified pull request

  login [<user>] [<password>] [<two-factor-auth-token>]
                              Login to GitHub and receive an access token (deprecated)
  authorize                   Create a GitHub OAuth personal access token
  comment <number> [<text>]   Create a comment on the specified pull request
  close <number>              Close the specified pull request
  open <number>               Reopen the specified pull request

    return 0;
}


sub login {
    my ($self, $user, $password, $two_factor_token) = @_;

    # Add deprecation message
    say "\nThis authorization method is deprecated and will be removed on November 13, 2020.";
    say "Please use the 'authorize' command to authenticate with GitHub.\n";

    # Try to fetch user/password from git config (or prompt)
    $user     ||= _qx('git', "config github.user")     || _prompt('GitHub username');
    $password ||= _qx('git', "config github.password") || _prompt('GitHub password', 'hidden');
    die("Please specify a user name.\n") unless $user;
    die("Please specify a password.\n")  unless $password;
    # Prompt for two-factor auth token
    $two_factor_token ||= _prompt('GitHub two-factor authentication token (if any)');

    # Perform authentication
    my $auth = _api_create(

            "scopes"   => [qw( public_repo repo )],
            "note"     => __PACKAGE__,
            "note_url" => 'https://metacpan/module/' . __PACKAGE__,
        },
        $user,
        $password,
        $two_factor_token,
    );
    die("Unable to authenticate with GitHub.\n")
        unless defined $auth;
    my $token = $auth->{'token'};


    die("No valid GitHub repo found. List of remotes exhausted.\n");
}

# Ask the user for some information
# Disable local echo if $hide_echo is true (for passwords)
sub _prompt {
    my ($label, $hide_echo) = @_;
    _echo('off') if $hide_echo;
    print "$label: " if defined $label;
    my $input = scalar <STDIN>;

    return $content;
}

# Perform HTTP POST
sub _post_url {
    my ($url, $mimetype, $data, $user, $password, $two_factor_token) = @_;
    croak("Please specify a URL") unless $url;
    croak("Please specify a mimetype") unless $mimetype;
    croak("Please specify some data") unless $data;

    # See if we should use credentials
    my @credentials;
    if ( _is_api_url($url) ) {
        my $token = _qx('git', 'config github.pr-token');
        die("You must login before you can modify information.\n")
            unless $token or ( $user and $password );
        if ( $user and $password ) {
            @credentials = ( '-u', "$user:$password" );
            push @credentials, '-H', "X-GitHub-OTP: $two_factor_token"
                if $two_factor_token;
        }
        else {
            @credentials = ( '-H', "Authorization: token $token" ) if $token;

external program.  This is usually a symlink set up by your operating system
to the most recently installed text editor.

The text must be encoded using UTF-8.

=head2 login [<user>] [<password>] [<2fa-token>]

DEPRECATED: Logs you in to GitHub and creates a new access token used
instead of your password and two-factor authentication token. If you don't
specify either of the options, they are looked up in your git config github
section. If none of those are found, you'll be prompted for them.

=head2 authorize [<access-token>]

view all matches for this distribution

App-GitKtti

1 match

README.md view on Meta::CPAN

#### Step 2: Configure PAUSE Credentials

```bash
# Create credentials file (one time setup)
echo "user YOUR_PAUSE_ID" > ~/.pause
echo "password YOUR_PASSWORD" >> ~/.pause
chmod 600 ~/.pause
```

Replace `YOUR_PAUSE_ID` and `YOUR_PASSWORD` with your actual PAUSE credentials.

view all matches for this distribution

App-GitUtils

1 match

script/gu view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--debug>

Shortcut for --log-level=debug.

view all matches for this distribution

App-Gitc

3 results

lib/App/Gitc/Its/Jira.pm view on Meta::CPAN


sub label_service { return 'JIRA'; }
sub label_issue   { return 'Issue'; }

our $default_jira_user     = 'someuser';
our $default_jira_password = 'somepassword';
our $jira_conf;

sub lookup_jira_user {
    my $self = shift;
    if (not $jira_conf and -e "$ENV{HOME}/.gitc/jira.conf") {
        $jira_conf = YAML::LoadFile("$ENV{HOME}/.gitc/jira.conf");
    } else {
        $jira_conf = {};
    }
    my $jira_user     = $jira_conf->{user} || $default_jira_user;
    my $jira_password = $jira_conf->{password} || $default_jira_password;
    return ($jira_user, $jira_password);
}

sub lookup_status_strings
{
    my $self = shift;

lib/App/Gitc/Its/Jira.pm view on Meta::CPAN


    # build and return the Issue object
    our %jira;
    my $jira = $jira{$uri};
    if ( not $jira ) {
        my ($jira_user, $jira_password) = $self->lookup_jira_user;
        $jira{$uri} = $jira
            = JIRA::Client->new( $uri, $jira_user, $jira_password );
        die "Unable to connect to JIRA SOAP API" unless $jira;
    }

    return $jira;
}

lib/App/Gitc/Its/Jira.pm view on Meta::CPAN


    # build and return the Issue object
    our %jira_rest;
    my $jira = $jira_rest{$uri};
    if ( not $jira ) {
        my ($jira_user, $jira_password) = $self->lookup_jira_user;
        $jira_rest{$uri} = $jira = JIRA::Client::REST->new(
               username => $jira_user,
               password => $jira_password,
               url => $uri,
           );
        die "Unable to connect to JIRA REST API" unless $jira;
    }

view all matches for this distribution

App-Glacier

1 match

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-GnuCash-MembershipUtils

1 match

lib/App/GnuCash/MembershipUtils.pm view on Meta::CPAN

    return ("filename '$filename' does not exist", undef) unless -f $filename;

    my $schema = GnuCash::Schema->connect(
        "dbi:SQLite:$filename",     # dsn
        undef,                      # user
        undef,                      # password
        {                           # dbi params
            sqlite_open_flags => DBD::SQLite::OPEN_READONLY,
        }
    );

view all matches for this distribution

App-Gnuget

1 match

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

view all matches for this distribution

App-GoogleSearchUtils

1 match