App-lcpan
view release on metacpan or search on metacpan
mentioned in the index, e.g. Foo-Bar-0.001.tar.gz which contains
module 'Foo::Bar' and script 'foo', some records like the 'foo'
script belonging to the file record are deleted along with it. Then
when a new file for the same distribution is added in the index,
e.g. Foo-Bar-0.002.tar.gz (which still contains the same 'Foo::Bar'
module and 'foo' script), the script record and some other records
are re-added to the lcpan index. This means lcpan sees the script
as new, when it's actually not. We now store old module record as
well as file and script records to old_* tables so we will be able
to know whether a distribution, module, or script is actually new
or just updated. But note that the last part has not been coded in
yet.
1.070 2022-03-27 Released-By: PERLANCAR; Urgency: medium
- Add subcommand: dists-by-mod-count.
1.069 2022-03-27 Released-By: PERLANCAR; Urgency: medium
- Add retrying and retry options: retry_max_attempts, retry_delay.
- We now use LWP::UserAgent::Plugin.
1.061 2020-06-11 Released-By: PERLANCAR; Urgency: medium
[subcommand mentions]
- Add --{added,updated,added-or-updated-}-* options.
[subcommand whatsnew]
- Show new mentions for you.
1.060 2020-06-11 Released-By: PERLANCAR; Urgency: medium
- [bugfix] Fix author-deps & author-rdeps which didn't apply the
{added,updated,added_or_updated}_since filter to the correct
entity (to module/dist instead of dep).
- [bugfix] Fix typo that caused --added-since-last-n-index-updates
to not work.
[subcommand whatsnew]
- Add --my-author option to show additional added/updated items related
to you.
1.059 2020-06-10 Released-By: PERLANCAR; Urgency: medium
- The --updated-since X option now does not include records created at
X, to avoid duplication when viewing new records as well as updated
records in the same time (e.g. in whatsnew).
[subcommand deps]
- [ux] Delete module_file_id from results.
1.058 2020-05-26 Released-By: PERLANCAR; Urgency: medium
- [incompatible change] Add/replace/rename/remove ctime/mtime
options: remove --{added,updated}-before, replace
--{added,updated}-after with --{added,updated}-since, rename
--{added,updated}-in-last-update to
--{added,updated}-since-last-index-update, rename
--{added,updated}-in-last-n-updates to
--{added,updated}-since-last-n-index-updates, add
--added-or-updated-since* options.
- Add some subcommands: most-depended-mods, most-mentioned-mods,
most-mentioned-scripts, whatsnew, heaviest-dists.
- Add option -n to mods-by-mention-count, mods-by-rdep-count,
scripts-by-mention-count, dists-by-dep-count.
[subcommand scripts-by-mention-count]
- Return author.
- [testing] Avoid error when testing database schema version upgrades.
1.055 2020-05-06 Released-By: PERLANCAR; Urgency: medium
- [testing] Add some basic tests, finally.
1.054 2020-05-06 Released-By: PERLANCAR; Urgency: medium
- [bugfix] Fix typo in translating --updated-in-last-update.
- Add convenience options --{added,updated}-in-last-n-updates=n.
- [subcommand log] Reorder lcpan_version column.
1.053 2020-05-05 Released-By: PERLANCAR; Urgency: medium
- Bump database schema version to v14 to add 'log' table.
- [subcommand reset] Reset index_creation_time metadata, add
description.
- [subcommand update][bugfix] Mark files that we skip sub indexing for,
so we don't re-process them again and again.
- Add convenience options --added-in-last-update,
--updated-in-last-update.
- [subcommand author-rdeps] Add --{added,updated}-* options.
1.052 2020-05-04 Released-By: PERLANCAR; Urgency: medium
- Bump database schema version to v13 to add rec_mtime and rec_mtime to
all tables. Recording ctime and mtime will allow users to check for
newly added/updated authors, distributions, modules, and so on.
- Add filter options --added-{before,after} & --updated-{before,after}
to some subcommands.
- Record index creation time and show it in 'stats'.
1.051 2020-04-20 Released-By: PERLANCAR; Urgency: medium
- Add unique indexes for PK which apparently are not added for tables
that have other unique indexes (bump database schema version to v12).
0.62 2016-01-04 Released-By: PERLANCAR
- [subcommand mods] Allow specifying multiple namespaces.
0.61 2015-12-31 Released-By: PERLANCAR
- No functional changes.
- [build] Rebuild with updated PWR:DumpPerinciCmdLineScript (0.04) which
lets us avoid extraneous subcommands from being included in the
bin/lcpan's POD.
0.60 2015-12-25 Released-By: PERLANCAR; Message: It's *this* Christmas!
- Replace --exact-match with the more general --query-type to be
able to search certain fields only or exact match on certain
fields only.
- [Bugfix] When indexing, used wrong dist_id (from last_insert_id())
when record already exists.
- [Bugfix] deps, rdeps: Result ordering fixes.
0.29 2015-04-24 Released-By: PERLANCAR
- [Bugfix] Fix missing dependencies/reverse dependencies information
when a depended module is updated, this is because we used INSERT OR
REPLACE {dist,module} which changes module/dist IDs. We should've used
INSERT or UPDATE. From this new version on we record the module
version which did the reindexing. We are doing a full reindex when
indexer <= 0.28.
0.28 2015-04-24 Released-By: PERLANCAR
- No functional changes.
authors();
* Find CPAN IDs which start with something:
authors(query => ["MICHAEL%"]); # -> ["MICHAEL", "MICHAELW", undef, {}]
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
* added_or_updated_since => *date*
Include only records that are added/updated since a certain date.
* added_or_updated_since_last_index_update => *true*
Include only records that are added/updated since the last index
update.
* added_or_updated_since_last_n_index_updates => *posint*
Include only records that are added/updated since the last N index
updates.
* cpan => *dirname*
Location of your local CPAN mirror, e.g. /path/to/cpan.
Defaults to "~/cpan".
* detail => *bool*
* sort => *array[str]* (default: ["id"])
Sort the result.
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
lcpan (like MetaCPAN) does not extract information from "Makefile.PL" or
"Build.PL" because that requires running (untrusted) code.
Also, some releases specify dynamic config, so there might actually be
more dependencies.
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
* added_or_updated_since => *date*
Include only records that are added/updated since a certain date.
* added_or_updated_since_last_index_update => *true*
Include only records that are added/updated since the last index
update.
* added_or_updated_since_last_n_index_updates => *posint*
Include only records that are added/updated since the last N index
updates.
* added_since => *date*
Include only records that are added since a certain date.
* added_since_last_index_update => *true*
Include only records that are added since the last index update.
* rel => *str* (default: "requires")
(No description)
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
* updated_since => *date*
Include only records that are updated since certain date.
* updated_since_last_index_update => *true*
Include only records that are updated since the last index update.
* updated_since_last_n_index_updates => *posint*
Include only records that are updated since the last N index
updates.
* use_bootstrap => *bool* (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to
turn this off.
* with_xs_or_pp => *bool*
dists(cpan => "/cpan", latest => 1);
* Grep by distribution name, return detailed record:
dists(query => ["data-table"], cpan => "/cpan");
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
* added_or_updated_since => *date*
Include only records that are added/updated since a certain date.
* added_or_updated_since_last_index_update => *true*
Include only records that are added/updated since the last index
update.
* added_or_updated_since_last_n_index_updates => *posint*
Include only records that are added/updated since the last N index
updates.
* added_since => *date*
Include only records that are added since a certain date.
* added_since_last_index_update => *true*
Include only records that are added since the last index update.
* sort => *array[str]* (default: ["dist"])
Sort the result.
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
* updated_since => *date*
Include only records that are updated since certain date.
* updated_since_last_index_update => *true*
Include only records that are updated since the last index update.
* updated_since_last_n_index_updates => *posint*
Include only records that are updated since the last N index
updates.
* use_bootstrap => *bool* (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to
turn this off.
Returns an enveloped result (an array).
index will be located in the top-level of "cpan". If "index_name"
contains a path, e.g. "./index.db" or "/home/ujang/lcpan.db" then
the index will be located solely using the "index_name".
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
Usage:
modules(%args) -> [$status_code, $reason, $payload, \%result_meta]
List modules/packages.
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
* added_or_updated_since => *date*
Include only records that are added/updated since a certain date.
* added_or_updated_since_last_index_update => *true*
Include only records that are added/updated since the last index
update.
* added_or_updated_since_last_n_index_updates => *posint*
Include only records that are added/updated since the last N index
updates.
* added_since => *date*
Include only records that are added since a certain date.
* added_since_last_index_update => *true*
Include only records that are added since the last index update.
* sort => *array[str]* (default: ["module"])
Sort the result.
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
* updated_since => *date*
Include only records that are updated since certain date.
* updated_since_last_index_update => *true*
Include only records that are updated since the last index update.
* updated_since_last_n_index_updates => *posint*
Include only records that are updated since the last N index
updates.
* use_bootstrap => *bool* (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to
turn this off.
Returns an enveloped result (an array).
Usage:
namespaces(%args) -> [$status_code, $reason, $payload, \%result_meta]
List namespaces.
This function is not exported.
Arguments ('*' denotes required arguments):
* added_or_updated_since => *date*
Include only records that are added/updated since a certain date.
* added_or_updated_since_last_index_update => *true*
Include only records that are added/updated since the last index
update.
* added_or_updated_since_last_n_index_updates => *posint*
Include only records that are added/updated since the last N index
updates.
* added_since => *date*
Include only records that are added since a certain date.
* added_since_last_index_update => *true*
Include only records that are added since the last index update.
* to_level => *int*
(No description)
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
* updated_since => *date*
Include only records that are updated since certain date.
* updated_since_last_index_update => *true*
Include only records that are updated since the last index update.
* updated_since_last_n_index_updates => *posint*
Include only records that are updated since the last N index
updates.
* use_bootstrap => *bool* (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to
turn this off.
Returns an enveloped result (an array).
Usage:
packages(%args) -> [$status_code, $reason, $payload, \%result_meta]
List modules/packages.
This function is not exported.
Arguments ('*' denotes required arguments):
* added_or_updated_since => *date*
Include only records that are added/updated since a certain date.
* added_or_updated_since_last_index_update => *true*
Include only records that are added/updated since the last index
update.
* added_or_updated_since_last_n_index_updates => *posint*
Include only records that are added/updated since the last N index
updates.
* added_since => *date*
Include only records that are added since a certain date.
* added_since_last_index_update => *true*
Include only records that are added since the last index update.
* sort => *array[str]* (default: ["module"])
Sort the result.
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
* updated_since => *date*
Include only records that are updated since certain date.
* updated_since_last_index_update => *true*
Include only records that are updated since the last index update.
* updated_since_last_n_index_updates => *posint*
Include only records that are updated since the last N index
updates.
* use_bootstrap => *bool* (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to
turn this off.
Returns an enveloped result (an array).
* List what distributions depend on one of the modules in
Sah-Schemas-Path:
rdeps(dists => ["Sah-Schemas-Path"]);
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
* added_or_updated_since => *date*
Include only records that are added/updated since a certain date.
* added_or_updated_since_last_index_update => *true*
Include only records that are added/updated since the last index
update.
* added_or_updated_since_last_n_index_updates => *posint*
Include only records that are added/updated since the last N index
updates.
* added_since => *date*
Include only records that are added since a certain date.
* added_since_last_index_update => *true*
Include only records that are added since the last index update.
* rel => *str* (default: "ALL")
(No description)
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
* updated_since => *date*
Include only records that are updated since certain date.
* updated_since_last_index_update => *true*
Include only records that are updated since the last index update.
* updated_since_last_n_index_updates => *posint*
Include only records that are updated since the last N index
updates.
* use_bootstrap => *bool* (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to
turn this off.
Returns an enveloped result (an array).
means file is not found in mirror (possibly because the mirroring
process excludes the file e.g. due to file size too large), "nometa"
means file does not contain META.{yml,json}, "unsupported" means file
archive format is not supported (e.g. rar), "err" means some other error
in processing file.
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
* added_or_updated_since => *date*
Include only records that are added/updated since a certain date.
* added_or_updated_since_last_index_update => *true*
Include only records that are added/updated since the last index
update.
* added_or_updated_since_last_n_index_updates => *posint*
Include only records that are added/updated since the last N index
updates.
* added_since => *date*
Include only records that are added since a certain date.
* added_since_last_index_update => *true*
Include only records that are added since the last index update.
* sort => *array[str]* (default: ["name"])
(No description)
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
* updated_since => *date*
Include only records that are updated since certain date.
* updated_since_last_index_update => *true*
Include only records that are updated since the last index update.
* updated_since_last_n_index_updates => *posint*
Include only records that are updated since the last N index
updates.
* use_bootstrap => *bool* (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to
turn this off.
Returns an enveloped result (an array).
index will be located in the top-level of "cpan". If "index_name"
contains a path, e.g. "./index.db" or "/home/ujang/lcpan.db" then
the index will be located solely using the "index_name".
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
index will be located in the top-level of "cpan". If "index_name"
contains a path, e.g. "./index.db" or "/home/ujang/lcpan.db" then
the index will be located solely using the "index_name".
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
* skip_sub_indexing_files => *array[str]*
Skip one or more files from being parsed for subs.
* update_db_schema => *bool* (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index
database, it updates the database schema to the latest if the
database happens to be last updated by an older version of the
application and has the old database schema (since database schema
is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the
database schema. This option is for testing only, because it will
probably cause the application to run abnormally and then die with a
SQL error when reading/writing to the database.
Note that in certain modes e.g. doing tab completion, the
application also will not update the database schema.
lib/App/lcpan.pm view on Meta::CPAN
tags => ['common'],
},
update_db_schema => {
summary => 'Whether to update database schema to the latest',
'summary.alt.bool.not' => 'Do not update database schema to the latest',
schema => 'bool*',
default => 1, # will also be checked/set in _set_args_default
description => <<'_',
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan.pm view on Meta::CPAN
tags => ['category:filtering'],
},
added_since_last_n_index_updates => {
summary => 'Include only records that are added since the last N index updates',
schema => 'posint*',
tags => ['category:filtering'],
},
);
our %fmtime_args = (
updated_since => {
summary => 'Include only records that are updated since certain date',
schema => ['date*', 'x.perl.coerce_rules' => ['From_str::natural']],
tags => ['category:filtering'],
},
updated_since_last_index_update => {
summary => 'Include only records that are updated since the last index update',
schema => 'true*',
tags => ['category:filtering'],
},
updated_since_last_n_index_updates => {
summary => 'Include only records that are updated since the last N index updates',
schema => 'posint*',
tags => ['category:filtering'],
},
);
our %fctime_or_mtime_args = (
added_or_updated_since => {
summary => 'Include only records that are added/updated since a certain date',
schema => ['date*', 'x.perl.coerce_rules' => ['From_str::natural']],
cmdline_aliases => {since=>{}},
tags => ['category:filtering'],
},
added_or_updated_since_last_index_update => {
summary => 'Include only records that are added/updated since the last index update',
schema => 'true*',
cmdline_aliases => {since_last_index_update=>{}},
tags => ['category:filtering'],
},
added_or_updated_since_last_n_index_updates => {
summary => 'Include only records that are added/updated since the last N index updates',
schema => 'posint*',
cmdline_aliases => {since_last_n_index_updates=>{}},
tags => ['category:filtering'],
},
);
our %perl_version_args = (
perl_version => {
summary => 'Set base Perl version for determining core modules',
schema => 'str*',
lib/App/lcpan.pm view on Meta::CPAN
$args->{cpan} = File::HomeDir->my_home . '/cpan';
}
$args->{index_name} //= 'index.db';
if (!defined($args->{num_backups})) {
$args->{num_backups} = 7;
}
$args->{use_bootstrap} //= 1;
$args->{update_db_schema} //= 1;
}
# set {added_,updated_,added_or_udpated_}since from
# {added_,updated_,added_or_updated_}since_last_{index_update,n_index_updates},
# set, since SQL query will usually use the former
sub _set_since {
my ($args, $dbh) = @_;
my $num_sinces = 0;
if (defined $args->{added_since}) { $num_sinces++ }
if (defined $args->{updated_since}) { $num_sinces++ }
if (defined $args->{added_or_updated_since}) { $num_sinces++ }
if (defined $args->{added_since_last_index_update} || defined $args->{updated_since_last_index_update} || defined $args->{added_or_updated_since_last_index_update}) {
my ($time) = $dbh->selectrow_array("SELECT date FROM log WHERE category='update_index' AND summary LIKE 'Begin%' ORDER BY date DESC");
die "Index has not been updated at all, cannot use {added_,updated_,added_or_updated_}since_last_index_update option" unless $time;
if (delete $args->{added_since_last_index_update}) { $args->{added_since} //= $time; log_trace "Setting added_since=%s", $time; $num_sinces++ }
if (delete $args->{updated_since_last_index_update}) { $args->{updated_since} //= $time; log_trace "Setting updated_since=%s", $time; $num_sinces++ }
if (delete $args->{added_or_updated_since_last_index_update}) { $args->{added_or_updated_since} //= $time; log_trace "Setting added_or_updated_since=%s", $time; $num_sinces++ }
}
if (defined $args->{added_since_last_n_index_updates} || defined $args->{updated_since_last_n_index_updates} || defined $args->{added_or_updated_since_last_n_index_updates}) {
my $n = int($args->{added_since_last_n_index_updates} // $args->{updated_since_last_n_index_updates} // $args->{added_or_updated_since_last_n_index_updates});
$n = 1 if $n < 1;
my $sth = $dbh->prepare("SELECT date FROM log WHERE category='update_index' AND summary LIKE 'Begin%' ORDER BY date DESC");
$sth->execute;
my $i = 0;
my $time;
1 while ++$i <= $n && (($time) = $sth->fetchrow_array);
die "Index has not been updated that many times, please set a lower number for {,added_,updated_}since_last_n_index_updates option" if $i < $n;
if (delete $args->{added_since_last_n_index_updates}) { $args->{added_since} //= $time; log_trace "Setting added_since=%s", $time; $num_sinces++ }
if (delete $args->{updated_since_last_n_index_updates}) { $args->{updated_since} //= $time; log_trace "Setting updated_since=%s", $time; $num_sinces++ }
if (delete $args->{added_or_updated_since_last_n_index_updates}) { $args->{added_or_updated_since} //= $time; log_trace "Setting added_or_updated_since=%s", $time; $num_sinces++ }
}
die "Multiple {added_,updated_,added_or_updated_}since options set, please set only one to avoid confusion" if $num_sinces > 1;
}
sub _add_since_where_clause {
my ($args, $where, $table) = @_;
if (defined $args->{added_since} ) { push @$where, "$table.rec_ctime >= ". (0+$args->{added_since}) }
if (defined $args->{updated_since}) { push @$where, "($table.rec_mtime >= ". (0+$args->{updated_since}). " AND $table.rec_ctime < ".(0+$args->{updated_since}). ")" }
if (defined $args->{added_or_updated_since}) { push @$where, "($table.rec_ctime >= ". (0+$args->{added_or_updated_since}). " OR $table.rec_mtime >= ". (0+$args->{added_or_updated_since}). ")" }
}
sub _fmt_time {
require POSIX;
my $epoch = shift;
return '' unless defined($epoch);
POSIX::strftime("%Y-%m-%dT%H:%M:%SZ", gmtime($epoch));
}
lib/App/lcpan.pm view on Meta::CPAN
my $mod_id;
if (($mod_id) = $dbh->selectrow_array("SELECT id FROM module WHERE name=?", {}, $pkg)) {
$sth_upd_mod->execute( $file_id, $author, $ver, _numify_ver($ver), time(), $pkg);
} else {
my $now = time();
$sth_ins_mod->execute($pkg, $file_id, $author, $ver, _numify_ver($ver), $now,$now);
$mod_id = $dbh->last_insert_id("","","","");
_set_namespace($dbh, $pkg);
}
log_trace(" New/updated module: %s (file ID=%d, module ID=%d)", $pkg, $file_id, $mod_id);
} # while <fh>
# cleanup: delete file record (as well as dists, modules, and deps
# records) for files in db that are no longer in 02packages.
CLEANUP:
{
my @old_file_ids;
my @old_file_entries; # ("author|filename", ...)
for my $k (sort keys %file_ids_in_table) {
next if exists $file_ids_in_02packages{$k};
lib/App/lcpan.pm view on Meta::CPAN
_update_files(%args); # it only returns 200 or dies
}
my @st2 = stat($packages_path);
if (!$args{update_index} && !$args{force_update_index}) {
log_info("Skipped updating index (reason: option update_index=0)");
} elsif (!$args{force_update_index} && $args{update_files} &&
@st1 && @st2 && $st1[9] == $st2[9] && $st1[7] == $st2[7]) {
log_info("%s doesn't change mtime/size, skipping updating index",
$packages_path);
return [304, "Files did not change, index not updated"];
} else {
my $res = _update_index(%args);
return $res unless $res->[0] == 200;
}
[200, "OK"];
}
sub _table_exists {
my ($dbh, $schema, $name) = @_;
my $sth = $dbh->table_info(undef, $schema, $name, undef);
lib/App/lcpan.pm view on Meta::CPAN
_set_since(\%args, $dbh);
my $filters = {
include_core => $include_core,
include_noncore => $include_noncore,
include_indexed => $include_indexed,
include_unindexed => $include_unindexed,
exclude_deps => $args{exclude_deps},
authors => $args{authors},
authors_arent => $args{authors_arent},
added_since => $args{added_since},
updated_since => $args{updated_since},
added_or_updated_since => $args{added_or_updated_since},
};
my $res = _get_prereqs($file_ids, $dbh, {}, {},
1, $level, $filters, $plver, $args{flatten}, $args{dont_uniquify}, $phase, $rel);
return $res unless $res->[0] == 200;
my @cols;
push @cols, (qw/module/);
push @cols, "dist" if @$file_ids > 1;
push @cols, (qw/author version/);
lib/App/lcpan.pm view on Meta::CPAN
(return [400, "Please specify modules OR dists"]);
my $level = $args{level} // 1;
my $authors = $args{authors} ? [map {uc} @{$args{authors}}] : undef;
my $authors_arent = $args{authors_arent} ? [map {uc} @{$args{authors_arent}}] : undef;
_set_since(\%args, $dbh);
my $filters = {
authors => $authors,
authors_arent => $authors_arent,
added_since => $args{added_since},
updated_since => $args{updated_since},
added_or_updated_since => $args{added_or_updated_since},
};
my $res = _get_revdeps($mods, $dbh, {}, {}, 1, $level, $filters, $args{flatten}, $args{dont_uniquify}, $args{phase}, $args{rel});
return $res unless $res->[0] == 200;
for (@{$res->[2]}) {
$_->{dist} = (" " x ($_->{level}-1)) . $_->{dist}
unless $args{flatten};
delete $_->{module} unless @$mods > 1 || $_->{level} > 1;
delete $_->{level};
lib/App/lcpan.pm view on Meta::CPAN
authors(query => ["MICHAEL%"]); # -> ["MICHAEL", "MICHAELW", undef, {}]
=back
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<cpan> => I<dirname>
Location of your local CPAN mirror, e.g. E<sol>pathE<sol>toE<sol>cpan.
Defaults to C<~/cpan>.
=item * B<detail> => I<bool>
(No description)
lib/App/lcpan.pm view on Meta::CPAN
=item * B<sort> => I<array[str]> (default: ["id"])
Sort the result.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan.pm view on Meta::CPAN
Also, some releases specify dynamic config, so there might actually be more
dependencies.
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<added_since> => I<date>
Include only records that are added since a certain date.
=item * B<added_since_last_index_update> => I<true>
Include only records that are added since the last index update.
=item * B<added_since_last_n_index_updates> => I<posint>
lib/App/lcpan.pm view on Meta::CPAN
=item * B<rel> => I<str> (default: "requires")
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
=item * B<updated_since> => I<date>
Include only records that are updated since certain date.
=item * B<updated_since_last_index_update> => I<true>
Include only records that are updated since the last index update.
=item * B<updated_since_last_n_index_updates> => I<posint>
Include only records that are updated since the last N index updates.
=item * B<use_bootstrap> => I<bool> (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to turn this
off.
=item * B<with_xs_or_pp> => I<bool>
lib/App/lcpan.pm view on Meta::CPAN
dists(query => ["data-table"], cpan => "/cpan");
=back
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<added_since> => I<date>
Include only records that are added since a certain date.
=item * B<added_since_last_index_update> => I<true>
Include only records that are added since the last index update.
=item * B<added_since_last_n_index_updates> => I<posint>
lib/App/lcpan.pm view on Meta::CPAN
=item * B<sort> => I<array[str]> (default: ["dist"])
Sort the result.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
=item * B<updated_since> => I<date>
Include only records that are updated since certain date.
=item * B<updated_since_last_index_update> => I<true>
Include only records that are updated since the last index update.
=item * B<updated_since_last_n_index_updates> => I<posint>
Include only records that are updated since the last N index updates.
=item * B<use_bootstrap> => I<bool> (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to turn this
off.
=back
lib/App/lcpan.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan.pm view on Meta::CPAN
modules(%args) -> [$status_code, $reason, $payload, \%result_meta]
List modulesE<sol>packages.
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<added_since> => I<date>
Include only records that are added since a certain date.
=item * B<added_since_last_index_update> => I<true>
Include only records that are added since the last index update.
=item * B<added_since_last_n_index_updates> => I<posint>
lib/App/lcpan.pm view on Meta::CPAN
=item * B<sort> => I<array[str]> (default: ["module"])
Sort the result.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
=item * B<updated_since> => I<date>
Include only records that are updated since certain date.
=item * B<updated_since_last_index_update> => I<true>
Include only records that are updated since the last index update.
=item * B<updated_since_last_n_index_updates> => I<posint>
Include only records that are updated since the last N index updates.
=item * B<use_bootstrap> => I<bool> (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to turn this
off.
=back
lib/App/lcpan.pm view on Meta::CPAN
namespaces(%args) -> [$status_code, $reason, $payload, \%result_meta]
List namespaces.
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<added_since> => I<date>
Include only records that are added since a certain date.
=item * B<added_since_last_index_update> => I<true>
Include only records that are added since the last index update.
=item * B<added_since_last_n_index_updates> => I<posint>
lib/App/lcpan.pm view on Meta::CPAN
=item * B<to_level> => I<int>
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
=item * B<updated_since> => I<date>
Include only records that are updated since certain date.
=item * B<updated_since_last_index_update> => I<true>
Include only records that are updated since the last index update.
=item * B<updated_since_last_n_index_updates> => I<posint>
Include only records that are updated since the last N index updates.
=item * B<use_bootstrap> => I<bool> (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to turn this
off.
=back
lib/App/lcpan.pm view on Meta::CPAN
packages(%args) -> [$status_code, $reason, $payload, \%result_meta]
List modulesE<sol>packages.
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<added_since> => I<date>
Include only records that are added since a certain date.
=item * B<added_since_last_index_update> => I<true>
Include only records that are added since the last index update.
=item * B<added_since_last_n_index_updates> => I<posint>
lib/App/lcpan.pm view on Meta::CPAN
=item * B<sort> => I<array[str]> (default: ["module"])
Sort the result.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
=item * B<updated_since> => I<date>
Include only records that are updated since certain date.
=item * B<updated_since_last_index_update> => I<true>
Include only records that are updated since the last index update.
=item * B<updated_since_last_n_index_updates> => I<posint>
Include only records that are updated since the last N index updates.
=item * B<use_bootstrap> => I<bool> (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to turn this
off.
=back
lib/App/lcpan.pm view on Meta::CPAN
rdeps(dists => ["Sah-Schemas-Path"]);
=back
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<added_since> => I<date>
Include only records that are added since a certain date.
=item * B<added_since_last_index_update> => I<true>
Include only records that are added since the last index update.
=item * B<added_since_last_n_index_updates> => I<posint>
lib/App/lcpan.pm view on Meta::CPAN
=item * B<rel> => I<str> (default: "ALL")
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
=item * B<updated_since> => I<date>
Include only records that are updated since certain date.
=item * B<updated_since_last_index_update> => I<true>
Include only records that are updated since the last index update.
=item * B<updated_since_last_n_index_updates> => I<posint>
Include only records that are updated since the last N index updates.
=item * B<use_bootstrap> => I<bool> (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to turn this
off.
=back
lib/App/lcpan.pm view on Meta::CPAN
e.g. due to file size too large), C<nometa> means file does not contain
META.{yml,json}, C<unsupported> means file archive format is not supported (e.g.
rar), C<err> means some other error in processing file.
This function is not exported by default, but exportable.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<added_since> => I<date>
Include only records that are added since a certain date.
=item * B<added_since_last_index_update> => I<true>
Include only records that are added since the last index update.
=item * B<added_since_last_n_index_updates> => I<posint>
lib/App/lcpan.pm view on Meta::CPAN
=item * B<sort> => I<array[str]> (default: ["name"])
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
=item * B<updated_since> => I<date>
Include only records that are updated since certain date.
=item * B<updated_since_last_index_update> => I<true>
Include only records that are updated since the last index update.
=item * B<updated_since_last_n_index_updates> => I<posint>
Include only records that are updated since the last N index updates.
=item * B<use_bootstrap> => I<bool> (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to turn this
off.
=back
lib/App/lcpan.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan.pm view on Meta::CPAN
=item * B<skip_sub_indexing_files> => I<array[str]>
Skip one or more files from being parsed for subs.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/author.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/author_deps.pm view on Meta::CPAN
my %deps_args = %args;
$deps_args{dists} = $dists;
delete $deps_args{author};
delete $deps_args{authors};
delete $deps_args{authors_arent};
$deps_args{authors} = delete $args{module_authors};
$deps_args{authors_arent} = delete $args{module_authors_arent};
$deps_args{phase} = delete $args{phase};
$deps_args{rel} = delete $args{rel};
$deps_args{added_since} = delete $args{added_since};
$deps_args{updated_since} = delete $args{updated_since};
$deps_args{added_or_updated_since} = delete $args{added_or_updated_since};
$res = App::lcpan::deps(%deps_args);
return $res if $res->[0] != 200;
$res;
}
1;
# ABSTRACT: List dependencies for all of the dists of an author
__END__
lib/App/lcpan/Cmd/author_deps.pm view on Meta::CPAN
distributions that are currently broken (not indexed on CPAN):
% lcpan author-deps YOURCPANID --broken --dont-uniquify
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<added_since> => I<date>
Include only records that are added since a certain date.
=item * B<added_since_last_index_update> => I<true>
Include only records that are added since the last index update.
=item * B<added_since_last_n_index_updates> => I<posint>
lib/App/lcpan/Cmd/author_deps.pm view on Meta::CPAN
=item * B<rel> => I<str> (default: "requires")
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
=item * B<updated_since> => I<date>
Include only records that are updated since certain date.
=item * B<updated_since_last_index_update> => I<true>
Include only records that are updated since the last index update.
=item * B<updated_since_last_n_index_updates> => I<posint>
Include only records that are updated since the last N index updates.
=item * B<use_bootstrap> => I<bool> (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to turn this
off.
=item * B<with_xs_or_pp> => I<bool>
lib/App/lcpan/Cmd/author_deps_by_dependent_count.pm view on Meta::CPAN
=item * B<rel> => I<str> (default: "requires")
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/author_dists.pm view on Meta::CPAN
=item * B<latest> => I<bool>
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/author_mods.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/author_mods_by_other_author_rdep_count.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/author_mods_by_rdep_count.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/author_rdeps.pm view on Meta::CPAN
my %rdeps_args = %args;
$rdeps_args{modules} = $mods;
delete $rdeps_args{author};
delete $rdeps_args{authors};
delete $rdeps_args{authors_arent};
$rdeps_args{authors} = delete $args{user_authors};
$rdeps_args{authors_arent} = delete $args{user_authors_arent};
$rdeps_args{phase} = delete $args{phase};
$rdeps_args{rel} = delete $args{rel};
$rdeps_args{added_since} = delete $args{added_since};
$rdeps_args{updated_since} = delete $args{updated_since};
$rdeps_args{added_or_updated_since} = delete $args{added_or_updated_since};
$res = App::lcpan::rdeps(%rdeps_args);
return $res if $res->[0] != 200;
$res;
}
1;
# ABSTRACT: Find distributions that use one of author's modules
__END__
lib/App/lcpan/Cmd/author_rdeps.pm view on Meta::CPAN
=item * B<rel> => I<str> (default: "ALL")
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
=item * B<updated_since> => I<date>
Include only records that are updated since certain date.
=item * B<updated_since_last_index_update> => I<true>
Include only records that are updated since the last index update.
=item * B<updated_since_last_n_index_updates> => I<posint>
Include only records that are updated since the last N index updates.
=item * B<use_bootstrap> => I<bool> (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to turn this
off.
=item * B<user_authors> => I<array[str]>
lib/App/lcpan/Cmd/author_rels.pm view on Meta::CPAN
=item * B<sort> => I<array[str]> (default: ["name"])
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/author_scripts.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/authors.pm view on Meta::CPAN
handle_cmd(query => ["MICHAEL%"]); # -> ["MICHAEL", "MICHAELW", undef, {}]
=back
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<cpan> => I<dirname>
Location of your local CPAN mirror, e.g. E<sol>pathE<sol>toE<sol>cpan.
Defaults to C<~/cpan>.
=item * B<detail> => I<bool>
(No description)
lib/App/lcpan/Cmd/authors.pm view on Meta::CPAN
=item * B<sort> => I<array[str]> (default: ["id"])
Sort the result.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/authors_by_dist_count.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/authors_by_filesize.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/authors_by_mod_count.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/authors_by_mod_mention_count.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/authors_by_rdep_count.pm view on Meta::CPAN
=item * B<rel> => I<str>
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/authors_by_rel_count.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/authors_by_script_count.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/changes.pm view on Meta::CPAN
=item * B<module_or_dist_or_script>* => I<str>
Module or dist or script name.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/contents.pm view on Meta::CPAN
=item * B<query_type> => I<str> (default: "any")
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/copy_mod.pm view on Meta::CPAN
=item * B<overwrite> => I<bool>
Whether to overwrite existing file.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/copy_rel.pm view on Meta::CPAN
=item * B<release>* => I<str>
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/copy_script.pm view on Meta::CPAN
=item * B<script>* => I<filename::unix>
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/db_path.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/delete_old_data.pm view on Meta::CPAN
If C<index_name> is a filename without any path, e.g. C<index.db> then index will
be located in the top-level of C<cpan>. If C<index_name> contains a path, e.g.
C<./index.db> or C</home/ujang/lcpan.db> then the index will be located solely
using the C<index_name>.
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/delete_rel.pm view on Meta::CPAN
=item * B<release>* => I<str>
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
lib/App/lcpan/Cmd/deps.pm view on Meta::CPAN
Also, some releases specify dynamic config, so there might actually be more
dependencies.
This function is not exported.
Arguments ('*' denotes required arguments):
=over 4
=item * B<added_or_updated_since> => I<date>
Include only records that are addedE<sol>updated since a certain date.
=item * B<added_or_updated_since_last_index_update> => I<true>
Include only records that are addedE<sol>updated since the last index update.
=item * B<added_or_updated_since_last_n_index_updates> => I<posint>
Include only records that are addedE<sol>updated since the last N index updates.
=item * B<added_since> => I<date>
Include only records that are added since a certain date.
=item * B<added_since_last_index_update> => I<true>
Include only records that are added since the last index update.
=item * B<added_since_last_n_index_updates> => I<posint>
lib/App/lcpan/Cmd/deps.pm view on Meta::CPAN
=item * B<rel> => I<str> (default: "requires")
(No description)
=item * B<update_db_schema> => I<bool> (default: 1)
Whether to update database schema to the latest.
By default, when the application starts and reads the index database, it updates
the database schema to the latest if the database happens to be last updated by
an older version of the application and has the old database schema (since
database schema is updated from time to time, for example at 1.070 the database
schema is at version 15).
When you disable this option, the application will not update the database
schema. This option is for testing only, because it will probably cause the
application to run abnormally and then die with a SQL error when reading/writing
to the database.
Note that in certain modes e.g. doing tab completion, the application also will
not update the database schema.
=item * B<updated_since> => I<date>
Include only records that are updated since certain date.
=item * B<updated_since_last_index_update> => I<true>
Include only records that are updated since the last index update.
=item * B<updated_since_last_n_index_updates> => I<posint>
Include only records that are updated since the last N index updates.
=item * B<use_bootstrap> => I<bool> (default: 1)
Whether to use bootstrap database from App-lcpan-Bootstrap.
If you are indexing your private CPAN-like repository, you want to turn this
off.
=item * B<with_xs_or_pp> => I<bool>
( run in 0.671 second using v1.01-cache-2.11-cpan-05444aca049 )