App-RecordStream
view release on metacpan or search on metacpan
[Documentation]
* Correct contributor information for Punyashloka Biswal
[Development]
* Add required author dependency on Test::Pod 1.41
4.0.21 2016-10-26 22:00:39 PDT
[Bug fixes]
* fromcsv: Fatalize parsing errors instead of silently stopping
* fromcsv: Support custom escape character to aid in parsing weird CSVs
[Documentation]
* Normalize more author names/addresses in the contributors list
[Tests]
* Travis CI: Test on Perl 5.22 and 5.24
[Development]
* Switch to Git::Contributors (away from ContributorsFromGit)
doc/recs-annotate.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-annotate.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
Help from: --help-snippet:
CODE SNIPPETS:
Recs code snippets are perl code, with one exception. There a couple of
variables predefined for you, and one piece of special syntax to assist in
modifying hashes.
doc/recs-annotate.pod view on Meta::CPAN
$filename - The filename of the originating record. Note: This is only
useful if you're passing filenames directly to the recs script, piping
from other recs scripts or from cat, for instance, will not have a
useful filename.
Special Syntax
Use {{search_string}} to look for a string in the keys of a record, use /
to nest keys. You can nest into arrays by using an index. If you are
vivifying arrays (if the array doesn't exist, prefix your key with # so
that an array rather than a hash will be created to put a / in your key,
escape it twice, i.e. \/
This is exactly the same as a key spec that is always prefaced with a @, see
'man recs' for more info on key specs
For example: A record that looks like:
{ "foo" : { "bar 1" : 1 }, "zoo" : 2}
Could be accessed like this:
# value of zoo # value of $r->{foo}->{bar 1}: (comma separate nested keys)
{{zoo}} {{foo/ar 1}}
doc/recs-assert.pod view on Meta::CPAN
$filename - The filename of the originating record. Note: This is only
useful if you're passing filenames directly to the recs script, piping
from other recs scripts or from cat, for instance, will not have a
useful filename.
Special Syntax
Use {{search_string}} to look for a string in the keys of a record, use /
to nest keys. You can nest into arrays by using an index. If you are
vivifying arrays (if the array doesn't exist, prefix your key with # so
that an array rather than a hash will be created to put a / in your key,
escape it twice, i.e. \/
This is exactly the same as a key spec that is always prefaced with a @, see
'man recs' for more info on key specs
For example: A record that looks like:
{ "foo" : { "bar 1" : 1 }, "zoo" : 2}
Could be accessed like this:
# value of zoo # value of $r->{foo}->{bar 1}: (comma separate nested keys)
{{zoo}} {{foo/ar 1}}
doc/recs-chain.pod view on Meta::CPAN
deserialization of records at each step in a complex recs pipeline. For ease
of use the chain of recs commands main contain non-recs command, anything
that does not start with a recs- is interpreted as a shell command. That
command is forked off to the shell. In this case, serialization and
deserialization costs apply, but only to and from the shell command,
everything else is done in memory. If you have many shell commands in a row,
there is extra over head, you should instead consider splitting those into
separate pipes. See the examples for more information on this.
Arugments are specified in on the command line separated by pipes. For most
shells, you will need to escape the pipe character to avoid having the shell
interpret the pipe as a shell pipe.
--show-chain Before running the commands, print out what will
happen in the chain
--n Do not run commands, implies --show-chain
--filename-key|fk <keyspec> Add a key with the source filename (if no
filename is applicable will put NONE)
Help Options:
--help-all Output all help for this script
doc/recs-chain.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-collate.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-collate.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
Help from: --help-more:
Usage: recs-collate <args> [<files>]
Take records, grouped togther by --keys, and compute statistics (like
average, count, sum, concat, etc) within those groups.
For starting with collate, try doing single --key collates with some number
doc/recs-delta.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-delta.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-eval.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
Help from: --help-snippet:
CODE SNIPPETS:
Recs code snippets are perl code, with one exception. There a couple of
variables predefined for you, and one piece of special syntax to assist in
modifying hashes.
doc/recs-eval.pod view on Meta::CPAN
$filename - The filename of the originating record. Note: This is only
useful if you're passing filenames directly to the recs script, piping
from other recs scripts or from cat, for instance, will not have a
useful filename.
Special Syntax
Use {{search_string}} to look for a string in the keys of a record, use /
to nest keys. You can nest into arrays by using an index. If you are
vivifying arrays (if the array doesn't exist, prefix your key with # so
that an array rather than a hash will be created to put a / in your key,
escape it twice, i.e. \/
This is exactly the same as a key spec that is always prefaced with a @, see
'man recs' for more info on key specs
For example: A record that looks like:
{ "foo" : { "bar 1" : 1 }, "zoo" : 2}
Could be accessed like this:
# value of zoo # value of $r->{foo}->{bar 1}: (comma separate nested keys)
{{zoo}} {{foo/ar 1}}
doc/recs-flatten.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-flatten.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-fromcsv.pod view on Meta::CPAN
output record. Fields are named numerically (0, 1, etc.), or as given by --
field, or as read by --header. Lines may be split on delimiters other than
commas by providing --delim.
Arguments:
--key|k <keys> Comma separated list of field names. May be
specified multiple times, may be key specs
--header Take field names from the first line of input
--strict Do not trim whitespaces, allow loose quoting
(quotes inside quotes), or allow the use of
escape characters when not strictly needed. (not
recommended, for most cases, though may help
with parsing quoted fields containing newlines)
--delim|-d <character> Field delimiter to use when reading input lines
(default ',').
--escape <character> Escape character used in quoted fields
(default '"').
--quote <character> Quote character used in quoted fields (default
'"'). Use the empty string to indicate no
quoted fields.
--filename-key|fk <keyspec> Add a key with the source filename (if no
filename is applicable will put NONE)
Help Options:
--help-all Output all help for this script
--help This help screen
doc/recs-fromcsv.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-frommultire.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-fromre.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-fromsplit.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-generate.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-grep.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
Help from: --help-snippet:
CODE SNIPPETS:
Recs code snippets are perl code, with one exception. There a couple of
variables predefined for you, and one piece of special syntax to assist in
modifying hashes.
doc/recs-grep.pod view on Meta::CPAN
$filename - The filename of the originating record. Note: This is only
useful if you're passing filenames directly to the recs script, piping
from other recs scripts or from cat, for instance, will not have a
useful filename.
Special Syntax
Use {{search_string}} to look for a string in the keys of a record, use /
to nest keys. You can nest into arrays by using an index. If you are
vivifying arrays (if the array doesn't exist, prefix your key with # so
that an array rather than a hash will be created to put a / in your key,
escape it twice, i.e. \/
This is exactly the same as a key spec that is always prefaced with a @, see
'man recs' for more info on key specs
For example: A record that looks like:
{ "foo" : { "bar 1" : 1 }, "zoo" : 2}
Could be accessed like this:
# value of zoo # value of $r->{foo}->{bar 1}: (comma separate nested keys)
{{zoo}} {{foo/ar 1}}
doc/recs-join.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
Help from: --help-snippet:
CODE SNIPPETS:
Recs code snippets are perl code, with one exception. There a couple of
variables predefined for you, and one piece of special syntax to assist in
modifying hashes.
doc/recs-join.pod view on Meta::CPAN
$filename - The filename of the originating record. Note: This is only
useful if you're passing filenames directly to the recs script, piping
from other recs scripts or from cat, for instance, will not have a
useful filename.
Special Syntax
Use {{search_string}} to look for a string in the keys of a record, use /
to nest keys. You can nest into arrays by using an index. If you are
vivifying arrays (if the array doesn't exist, prefix your key with # so
that an array rather than a hash will be created to put a / in your key,
escape it twice, i.e. \/
This is exactly the same as a key spec that is always prefaced with a @, see
'man recs' for more info on key specs
For example: A record that looks like:
{ "foo" : { "bar 1" : 1 }, "zoo" : 2}
Could be accessed like this:
# value of zoo # value of $r->{foo}->{bar 1}: (comma separate nested keys)
{{zoo}} {{foo/ar 1}}
doc/recs-multiplex.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-multiplex.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
Help from: --help-more:
Usage: recs-multiplex <args> -- <other recs operation>
Take records, grouped together by --keys, and run an operation for
each group.
Arguments:
doc/recs-normalizetime.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-sort.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-stream2table.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-substream.pod view on Meta::CPAN
$filename - The filename of the originating record. Note: This is only
useful if you're passing filenames directly to the recs script, piping
from other recs scripts or from cat, for instance, will not have a
useful filename.
Special Syntax
Use {{search_string}} to look for a string in the keys of a record, use /
to nest keys. You can nest into arrays by using an index. If you are
vivifying arrays (if the array doesn't exist, prefix your key with # so
that an array rather than a hash will be created to put a / in your key,
escape it twice, i.e. \/
This is exactly the same as a key spec that is always prefaced with a @, see
'man recs' for more info on key specs
For example: A record that looks like:
{ "foo" : { "bar 1" : 1 }, "zoo" : 2}
Could be accessed like this:
# value of zoo # value of $r->{foo}->{bar 1}: (comma separate nested keys)
{{zoo}} {{foo/ar 1}}
doc/recs-tocsv.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-tocsv.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-todb.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-togdgraph.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-togdgraph.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-tognuplot.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-tognuplot.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-tohtml.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-tohtml.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-topn.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-topn.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-toprettyprint.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-toprettyprint.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-toptable.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-toptable.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-totable.pod view on Meta::CPAN
fields to a recs command with a single argument or function. They are
generally regexes, and have several options to control what fields they
match. By default you give a regex, and it will be matched against all first
level keys of a record to come up with the record list. For instance, in a
record like this:
{ 'zip': 1, 'zap': 2, 'foo': { 'bar': 3 } }
Key group: !z! would get the keys 'zip' and 'zap'
You can have a literal '!' in your regex, just escape it with a \.
Normally, key groups will only match keys whose values are scalars. This can
be changed with the 'returnrefs' or rr flag.
With the above record !f! would match no fields, but !f!rr would match foo
(which has a value of a hash ref)
Options on KeyGroups:
returnrefs, rr - Return keys that have reference values (default:off)
full, f - Regex should match against full keys (recurse fully)
doc/recs-totable.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
=head1 SEE ALSO
=over
=item * See L<App::RecordStream> for an overview of the scripts and the system
doc/recs-xform.pod view on Meta::CPAN
Fuzzy matching works like this in order, first key to match wins
1. Exact match ( eq )
2. Prefix match ( m/^/ )
3. Match anywehre in the key (m//)
So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
would be the index into the array, so all records would have the value of 'c'
Simiarly, @f/b would have values 1, 2, and 3
You can escape / with a \. For example, if you have a record:
{"foo/bar":2}
You can address that key with foo\/bar
Help from: --help-snippet:
CODE SNIPPETS:
Recs code snippets are perl code, with one exception. There a couple of
variables predefined for you, and one piece of special syntax to assist in
modifying hashes.
doc/recs-xform.pod view on Meta::CPAN
$filename - The filename of the originating record. Note: This is only
useful if you're passing filenames directly to the recs script, piping
from other recs scripts or from cat, for instance, will not have a
useful filename.
Special Syntax
Use {{search_string}} to look for a string in the keys of a record, use /
to nest keys. You can nest into arrays by using an index. If you are
vivifying arrays (if the array doesn't exist, prefix your key with # so
that an array rather than a hash will be created to put a / in your key,
escape it twice, i.e. \/
This is exactly the same as a key spec that is always prefaced with a @, see
'man recs' for more info on key specs
For example: A record that looks like:
{ "foo" : { "bar 1" : 1 }, "zoo" : 2}
Could be accessed like this:
# value of zoo # value of $r->{foo}->{bar 1}: (comma separate nested keys)
{{zoo}} {{foo/ar 1}}
( run in 0.645 second using v1.01-cache-2.11-cpan-c21f80fb71c )