App-Genpass-ID
view release on metacpan or search on metacpan
script/_genpass-id view on Meta::CPAN
# }
#
# if ( $class_name ) {
# bless $copy, $class_name;
# $copy->$CloneInitMethod() if $copy->can($CloneInitMethod);
# }
#
# return $copy;
#}
#
#1;
#
#__END__
#
### Complete/Bash.pm ###
#package Complete::Bash;
#
#our $DATE = '2016-12-28';
#our $VERSION = '0.31';
#
#use 5.010001;
#use strict;
#use warnings;
#
#require Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw(
# point
# parse_cmdline
# join_wordbreak_words
# format_completion
# );
#
#our %SPEC;
#
#$SPEC{':package'} = {
# v => 1.1,
# summary => 'Completion routines for bash shell',
#};
#
#sub _expand_tilde {
# my ($user, $slash) = @_;
# my @ent;
# if (length $user) {
# @ent = getpwnam($user);
# } else {
# @ent = getpwuid($>);
# $user = $ent[0];
# }
# return $ent[7] . $slash if @ent;
# "~$user$slash";
#}
#
#sub _add_unquoted {
# no warnings 'uninitialized';
#
# my ($word, $is_cur_word, $after_ws) = @_;
#
#
# $word =~ s!^(~)(\w*)(/|\z) | # 1) tilde 2) username 3) optional slash
# \\(.) | # 4) escaped char
# \$(\w+) # 5) variable name
# !
# $1 ? (not($after_ws) || $is_cur_word ? "$1$2$3" : _expand_tilde($2, $3)) :
# $4 ? $4 :
# ($is_cur_word ? "\$$5" : $ENV{$5})
# !egx;
# $word;
#}
#
#sub _add_double_quoted {
# no warnings 'uninitialized';
#
# my ($word, $is_cur_word) = @_;
#
# $word =~ s!\\(.) | # 1) escaped char
# \$(\w+) # 2) variable name
# !
# $1 ? $1 :
# ($is_cur_word ? "\$$2" : $ENV{$2})
# !egx;
# $word;
#}
#
#sub _add_single_quoted {
# my $word = shift;
# $word =~ s/\\(.)/$1/g;
# $word;
#}
#
#$SPEC{point} = {
# v => 1.1,
# summary => 'Return line with point marked by a marker',
# description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
# point("^foo") # => ("foo", 0)
# point("fo^o") # => ("foo", 2)
#
#_
# args_as => 'array',
# args => {
# cmdline => {
# summary => 'Command-line which contains a marker character',
# schema => 'str*',
# pos => 0,
# },
# marker => {
# summary => 'Marker character',
# schema => ['str*', len=>1],
# default => '^',
# pos => 1,
# },
# },
# result_naked => 1,
#};
#sub point {
# my ($line, $marker) = @_;
# $marker //= '^';
#
# my $point = index($line, $marker);
# die "BUG: No marker '$marker' in line <$line>" unless $point >= 0;
# $line =~ s/\Q$marker\E//;
# ($line, $point);
#}
#
#$SPEC{parse_cmdline} = {
# v => 1.1,
# summary => 'Parse shell command-line for processing by completion routines',
# description => <<'_',
#
#This function basically converts `COMP_LINE` (str) and `COMP_POINT` (int) into
#something like (but not exactly the same as) `COMP_WORDS` (array) and
#`COMP_CWORD` (int) that bash supplies to shell functions.
#
#The differences with bash are (these differences are mostly for parsing
#convenience for programs that use this routine; this comparison is made against
#bash versions 4.2-4.3):
#
#1) quotes and backslashes are stripped (bash's `COMP_WORDS` contains all the
# quotes and backslashes);
#
#2) quoted phrase that contains spaces, or phrase that contains escaped spaces is
# parsed as a single word. For example:
#
# command "First argument" Second\ argument
#
# bash would split it as (represented as Perl):
#
# ["command", "\"First", "argument\"", "Second\\", "argument"]
#
# which is not very convenient. We parse it into:
#
# ["command", "First argument", "Second argument"]
#
#3) variables are substituted with their values from environment variables except
# for the current word (`COMP_WORDS[COMP_CWORD]`) (bash does not perform
# variable substitution for `COMP_WORDS`). However, note that special shell
# variables that are not environment variables like `$0`, `$_`, `$IFS` will not
# be replaced correctly because bash does not export those variables for us.
#
#4) tildes (`~`) are expanded with user's home directory except for the current
# word (bash does not perform tilde expansion for `COMP_WORDS`);
#
#Caveats:
#
#* Like bash, we group non-whitespace word-breaking characters into its own word.
# By default `COMP_WORDBREAKS` is:
#
# "'@><=;|&(:
#
# So if raw command-line is:
#
# command --foo=bar http://example.com:80 mail@example.org Foo::Bar
#
# then the parse result will be:
#
# ["command", "--foo", "=", "bar", "http", ":", "//example.com", ":", "80", "Foo", "::", "Bar"]
#
# which is annoying sometimes. But we follow bash here so we can more easily
# accept input from a joined `COMP_WORDS` if we write completion bash functions,
# e.g. (in the example, `foo` is a Perl script):
#
# _foo ()
# {
# local words=(${COMP_CWORDS[@]})
# # add things to words, etc
# local point=... # calculate the new point
# COMPREPLY=( `COMP_LINE="foo ${words[@]}" COMP_POINT=$point foo` )
# }
#
# To avoid these word-breaking characters to be split/grouped, we can escape
# them with backslash or quote them, e.g.:
#
# command "http://example.com:80" Foo\:\:Bar
#
# which bash will parse as:
#
# ["command", "\"http://example.com:80\"", "Foo\\:\\:Bar"]
#
# and we parse as:
#
# ["command", "http://example.com:80", "Foo::Bar"]
#
#* Due to the way bash parses the command line (see above), the two below are
# equivalent:
#
# % cmd --foo=bar
# % cmd --foo = bar
#
#Because they both expand to `['--foo', '=', 'bar']`. But obviously
#<pm:Getopt::Long> does not regard the two as equivalent.
#
#_
# args_as => 'array',
# args => {
# cmdline => {
# summary => 'Command-line, defaults to COMP_LINE environment',
# schema => 'str*',
# pos => 0,
# },
# point => {
# summary => 'Point/position to complete in command-line, '.
# 'defaults to COMP_POINT',
# schema => 'int*',
# pos => 1,
# },
# opts => {
# summary => 'Options',
# schema => 'hash*',
# description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
# position of cursor, for example (`^` marks the position of cursor):
# `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
# doing tab completion.
#
#_
# schema => 'hash*',
# pos => 2,
# },
# },
# result => {
# schema => ['array*', len=>2],
# description => <<'_',
#
#Return a 2-element array: `[$words, $cword]`. `$words` is array of str,
#equivalent to `COMP_WORDS` provided by bash to shell functions. `$cword` is an
#integer, roughly equivalent to `COMP_CWORD` provided by bash to shell functions.
#The word to be completed is at `$words->[$cword]`.
script/_genpass-id view on Meta::CPAN
#
# [\@words, $cword];
#}
#
#$SPEC{join_wordbreak_words} = {
# v => 1.1,
# summary => 'Post-process parse_cmdline() result by joining some words',
# description => <<'_',
#
#`parse_cmdline()`, like bash, splits some characters that are considered as
#word-breaking characters:
#
# "'@><=;|&(:
#
#So if command-line is:
#
# command -MData::Dump bob@example.org
#
#then they will be parsed as:
#
# ["command", "-MData", "::", "Dump", "bob", '@', "example.org"]
#
#Normally in Perl applications, we want `:`, `@` to be part of word. So this
#routine will convert the above into:
#
# ["command", "-MData::Dump", 'bob@example.org']
#
#_
#};
#sub join_wordbreak_words {
# my ($words, $cword) = @_;
# my $new_words = [];
# my $i = -1;
# while (++$i < @$words) {
# my $w = $words->[$i];
# if ($w =~ /\A[\@=:]+\z/) {
# if (@$new_words and $#$new_words != $cword) {
# $new_words->[-1] .= $w;
# $cword-- if $cword >= $i || $cword >= @$new_words;
# } else {
# push @$new_words, $w;
# }
# if ($i+1 < @$words) {
# $i++;
# $new_words->[-1] .= $words->[$i];
# $cword-- if $cword >= $i || $cword >= @$new_words;
# }
# } else {
# push @$new_words, $w;
# }
# }
# [$new_words, $cword];
#}
#
#$SPEC{format_completion} = {
# v => 1.1,
# summary => 'Format completion for output (for shell)',
# description => <<'_',
#
#Bash accepts completion reply in the form of one entry per line to STDOUT. Some
#characters will need to be escaped. This function helps you do the formatting,
#with some options.
#
#This function accepts completion answer structure as described in the `Complete`
#POD. Aside from `words`, this function also recognizes these keys:
#
#* `as` (str): Either `string` (the default) or `array` (to return array of lines
# instead of the lines joined together). Returning array is useful if you are
# doing completion inside `Term::ReadLine`, for example, where the library
# expects an array.
#
#* `esc_mode` (str): Escaping mode for entries. Either `default` (most
# nonalphanumeric characters will be escaped), `shellvar` (like `default`, but
# dollar sign `$` will not be escaped, convenient when completing environment
# variables for example), `filename` (currently equals to `default`), `option`
# (currently equals to `default`), or `none` (no escaping will be done).
#
#* `path_sep` (str): If set, will enable "path mode", useful for
# completing/drilling-down path. Below is the description of "path mode".
#
# In shell, when completing filename (e.g. `foo`) and there is only a single
# possible completion (e.g. `foo` or `foo.txt`), the shell will display the
# completion in the buffer and automatically add a space so the user can move to
# the next argument. This is also true when completing other values like
# variables or program names.
#
# However, when completing directory (e.g. `/et` or `Downloads`) and there is
# solely a single completion possible and it is a directory (e.g. `/etc` or
# `Downloads`), the shell automatically adds the path separator character
# instead (`/etc/` or `Downloads/`). The user can press Tab again to complete
# for files/directories inside that directory, and so on. This is obviously more
# convenient compared to when shell adds a space instead.
#
# The `path_sep` option, when set, will employ a trick to mimic this behaviour.
# The trick is, if you have a completion array of `['foo/']`, it will be changed
# to `['foo/', 'foo/ ']` (the second element is the first element with added
# space at the end) to prevent bash from adding a space automatically.
#
# Path mode is not restricted to completing filesystem paths. Anything path-like
# can use it. For example when you are completing Java or Perl module name (e.g.
# `com.company.product.whatever` or `File::Spec::Unix`) you can use this mode
# (with `path_sep` appropriately set to, e.g. `.` or `::`).
#
#_
# args_as => 'array',
# args => {
# completion => {
# summary => 'Completion answer structure',
# description => <<'_',
#
#Either an array or hash. See function description for more details.
#
#_
# schema=>['any*' => of => ['hash*', 'array*']],
# req=>1,
# pos=>0,
# },
# opts => {
# schema=>'hash*',
# pos=>1,
# },
# },
# result => {
# summary => 'Formatted string (or array, if `as` is set to `array`)',
# schema => ['any*' => of => ['str*', 'array*']],
# },
# result_naked => 1,
#};
#sub format_completion {
# my ($hcomp, $opts) = @_;
#
# $opts //= {};
#
# $hcomp = {words=>$hcomp} unless ref($hcomp) eq 'HASH';
script/_genpass-id view on Meta::CPAN
#use Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw(
# single_quote
# double_quote
# );
#
#my %esc = (
# "\a" => "\\a",
# "\b" => "\\b",
# "\t" => "\\t",
# "\n" => "\\n",
# "\f" => "\\f",
# "\r" => "\\r",
# "\e" => "\\e",
#);
#
#sub double_quote {
# local($_) = $_[0];
# s/([\\\"\@\$])/\\$1/g;
# return qq("$_") unless /[^\040-\176]/;
#
# s/([\a\b\t\n\f\r\e])/$esc{$1}/g;
#
# s/([\0-\037])(?!\d)/sprintf('\\%o',ord($1))/eg;
#
# s/([\0-\037\177-\377])/sprintf('\\x%02X',ord($1))/eg;
# s/([^\040-\176])/sprintf('\\x{%X}',ord($1))/eg;
#
# return qq("$_");
#}
#
#sub single_quote {
# local($_) = $_[0];
# s/([\\'])/\\$1/g;
# return qq('$_');
#}
#1;
#
#__END__
#
### String/Wildcard/Bash.pm ###
#package String::Wildcard::Bash;
#
#use 5.010001;
#use strict;
#use warnings;
#
#our $VERSION = '0.03';
#
#use Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw(
# $RE_WILDCARD_BASH
# contains_wildcard
# convert_wildcard_to_sql
# );
#
#our $RE_WILDCARD_BASH =
# qr(
# # non-escaped brace expression, with at least one comma
# (?P<brace>
# (?<!\\)(?:\\\\)*\{
# (?: \\\\ | \\\{ | \\\} | [^\\\{\}] )*
# (?:, (?: \\\\ | \\\{ | \\\} | [^\\\{\}] )* )+
# (?<!\\)(?:\\\\)*\}
# )
# |
# # non-escaped brace expression, to catch * or ? or [...] inside so
# # they don't go to below pattern, because bash doesn't consider them
# # wildcards, e.g. '/{et?,us*}' expands to '/etc /usr', but '/{et?}'
# # doesn't expand at all to /etc.
# (?P<braceno>
# (?<!\\)(?:\\\\)*\{
# (?: \\\\ | \\\{ | \\\} | [^\\\{\}] )*
# (?<!\\)(?:\\\\)*\}
# )
# |
# (?P<class>
# # non-empty, non-escaped character class
# (?<!\\)(?:\\\\)*\[
# (?: \\\\ | \\\[ | \\\] | [^\\\[\]] )+
# (?<!\\)(?:\\\\)*\]
# )
# |
# (?P<joker>
# # non-escaped * and ?
# (?<!\\)(?:\\\\)*[*?]
# )
# |
# (?P<sql_wc>
# # non-escaped % and ?
# (?<!\\)(?:\\\\)*[%_]
# )
# )ox;
#
#sub contains_wildcard {
# my $str = shift;
#
# while ($str =~ /$RE_WILDCARD_BASH/go) {
# my %m = %+;
# return 1 if $m{brace} || $m{class} || $m{joker};
# }
# 0;
#}
#
#sub convert_wildcard_to_sql {
# my $str = shift;
#
# $str =~ s/$RE_WILDCARD_BASH/
# if ($+{joker}) {
# if ($+{joker} eq '*') {
# "%";
# } else {
# "_";
# }
# } elsif ($+{sql_wc}) {
# "\\$+{sql_wc}";
# } else {
# $&;
# }
# /eg;
#
# $str;
#}
#
#1;
#
#__END__
#
### YAML/Old.pm ###
#package YAML::Old;
#our $VERSION = '1.23';
#
#use YAML::Old::Mo;
#
#use Exporter;
#push @YAML::Old::ISA, 'Exporter';
#our @EXPORT = qw{ Dump Load };
#our @EXPORT_OK = qw{ freeze thaw DumpFile LoadFile Bless Blessed };
#our (
# $UseCode, $DumpCode, $LoadCode,
# $SpecVersion,
# $UseHeader, $UseVersion, $UseBlock, $UseFold, $UseAliases,
# $Indent, $SortKeys, $Preserve,
# $AnchorPrefix, $CompressSeries, $InlineSeries, $Purity,
# $Stringify, $Numify
#);
#
#
#use YAML::Old::Node;
#use Scalar::Util qw/ openhandle /;
script/_genpass-id view on Meta::CPAN
# if $self->is_valid_plain($_[0]);
# $self->_emit($sf),
# $self->_emit_double($_[0]),
# $self->_emit($ef), last
# if $_[0] =~ /'/;
# $self->_emit($sf),
# $self->_emit_single($_[0]),
# $self->_emit($ef);
# last;
# }
#
# $self->{level}--;
#
# return;
#}
#
#sub is_literal_number {
# my $self = shift;
# return B::svref_2object(\$_[0])->FLAGS & (B::SVp_IOK | B::SVp_NOK)
# && 0 + $_[0] eq $_[0];
#}
#
#sub _emit_number {
# my $self = shift;
# return $self->_emit_plain($_[0]);
#}
#
#sub is_valid_plain {
# my $self = shift;
# return 0 unless length $_[0];
# return 0 if $self->quote_numeric_strings and Scalar::Util::looks_like_number($_[0]);
# return 0 if $_[0] =~ /^[\s\{\[\~\`\'\"\!\@\#\>\|\%\&\?\*\^]/;
# return 0 if $_[0] =~ /[\{\[\]\},]/;
# return 0 if $_[0] =~ /[:\-\?]\s/;
# return 0 if $_[0] =~ /\s#/;
# return 0 if $_[0] =~ /\:(\s|$)/;
# return 0 if $_[0] =~ /[\s\|\>]$/;
# return 0 if $_[0] eq '-';
# return 1;
#}
#
#sub _emit_block {
# my $self = shift;
# my ($indicator, $value) = @_;
# $self->{stream} .= $indicator;
# $value =~ /(\n*)\Z/;
# my $chomp = length $1 ? (length $1 > 1) ? '+' : '' : '-';
# $value = '~' if not defined $value;
# $self->{stream} .= $chomp;
# $self->{stream} .= $self->indent_width if $value =~ /^\s/;
# $self->{stream} .= $self->indent($value);
#}
#
#sub _emit_plain {
# my $self = shift;
# $self->{stream} .= defined $_[0] ? $_[0] : '~';
#}
#
#sub _emit_double {
# my $self = shift;
# (my $escaped = $self->escape($_[0])) =~ s/"/\\"/g;
# $self->{stream} .= qq{"$escaped"};
#}
#
#sub _emit_single {
# my $self = shift;
# my $item = shift;
# $item =~ s{'}{''}g;
# $self->{stream} .= "'$item'";
#}
#
#
#sub indent {
# my $self = shift;
# my ($text) = @_;
# return $text unless length $text;
# $text =~ s/\n\Z//;
# my $indent = ' ' x $self->offset->[$self->level];
# $text =~ s/^/$indent/gm;
# $text = "\n$text";
# return $text;
#}
#
#my @escapes = qw(\0 \x01 \x02 \x03 \x04 \x05 \x06 \a
# \x08 \t \n \v \f \r \x0e \x0f
# \x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17
# \x18 \x19 \x1a \e \x1c \x1d \x1e \x1f
# );
#
#sub escape {
# my $self = shift;
# my ($text) = @_;
# $text =~ s/\\/\\\\/g;
# $text =~ s/([\x00-\x1f])/$escapes[ord($1)]/ge;
# return $text;
#}
#
#1;
### YAML/Old/Dumper/Base.pm ###
#package YAML::Old::Dumper::Base;
#
#use YAML::Old::Mo;
#
#use YAML::Old::Node;
#
#has spec_version => default => sub {'1.0'};
#has indent_width => default => sub {2};
#has use_header => default => sub {1};
#has use_version => default => sub {0};
#has sort_keys => default => sub {1};
#has anchor_prefix => default => sub {''};
#has dump_code => default => sub {0};
#has use_block => default => sub {0};
#has use_fold => default => sub {0};
#has compress_series => default => sub {1};
#has inline_series => default => sub {0};
#has use_aliases => default => sub {1};
#has purity => default => sub {0};
#has stringify => default => sub {0};
#has quote_numeric_strings => default => sub {0};
#
#has stream => default => sub {''};
#has document => default => sub {0};
#has transferred => default => sub {{}};
#has id_refcnt => default => sub {{}};
#has id_anchor => default => sub {{}};
#has anchor => default => sub {1};
#has level => default => sub {0};
#has offset => default => sub {[]};
#has headless => default => sub {0};
#has blessed_map => default => sub {{}};
#
#sub set_global_options {
# my $self = shift;
# $self->spec_version($YAML::SpecVersion)
# if defined $YAML::SpecVersion;
# $self->indent_width($YAML::Indent)
# if defined $YAML::Indent;
# $self->use_header($YAML::UseHeader)
# if defined $YAML::UseHeader;
# $self->use_version($YAML::UseVersion)
# if defined $YAML::UseVersion;
# $self->sort_keys($YAML::SortKeys)
# if defined $YAML::SortKeys;
# $self->anchor_prefix($YAML::AnchorPrefix)
# if defined $YAML::AnchorPrefix;
# $self->dump_code($YAML::DumpCode || $YAML::UseCode)
# if defined $YAML::DumpCode or defined $YAML::UseCode;
# $self->use_block($YAML::UseBlock)
# if defined $YAML::UseBlock;
# $self->use_fold($YAML::UseFold)
# if defined $YAML::UseFold;
# $self->compress_series($YAML::CompressSeries)
# if defined $YAML::CompressSeries;
script/_genpass-id view on Meta::CPAN
# if ($self->lines->[0] !~ /^---(\s|$)/) {
# unshift @{$self->lines}, '---';
# $self->{line}--;
# }
# }
#
# while (not $self->eos) {
# $self->anchor2node({});
# $self->{document}++;
# $self->done(0);
# $self->level(0);
# $self->offset->[0] = -1;
#
# if ($self->lines->[0] =~ /^---\s*(.*)$/) {
# my @words = split /\s+/, $1;
# %directives = ();
# while (@words && $words[0] =~ /^#(\w+):(\S.*)$/) {
# my ($key, $value) = ($1, $2);
# shift(@words);
# if (defined $directives{$key}) {
# $self->warn('YAML_PARSE_WARN_MULTIPLE_DIRECTIVES',
# $key, $self->document);
# next;
# }
# $directives{$key} = $value;
# }
# $self->preface(join ' ', @words);
# }
# else {
# $self->die('YAML_PARSE_ERR_NO_SEPARATOR');
# }
#
# if (not $self->done) {
# $self->_parse_next_line(COLLECTION);
# }
# if ($self->done) {
# $self->{indent} = -1;
# $self->content('');
# }
#
# $directives{YAML} ||= '1.0';
# $directives{TAB} ||= 'NONE';
# ($self->{major_version}, $self->{minor_version}) =
# split /\./, $directives{YAML}, 2;
# $self->die('YAML_PARSE_ERR_BAD_MAJOR_VERSION', $directives{YAML})
# if $self->major_version ne '1';
# $self->warn('YAML_PARSE_WARN_BAD_MINOR_VERSION', $directives{YAML})
# if $self->minor_version ne '0';
# $self->die('Unrecognized TAB policy')
# unless $directives{TAB} =~ /^(NONE|\d+)(:HARD)?$/;
#
# push @{$self->documents}, $self->_parse_node();
# }
# return wantarray ? @{$self->documents} : $self->documents->[-1];
#}
#
#sub _parse_node {
# my $self = shift;
# my $preface = $self->preface;
# $self->preface('');
# my ($node, $type, $indicator, $escape, $chomp) = ('') x 5;
# my ($anchor, $alias, $explicit, $implicit, $class) = ('') x 5;
# ($anchor, $alias, $explicit, $implicit, $preface) =
# $self->_parse_qualifiers($preface);
# if ($anchor) {
# $self->anchor2node->{$anchor} = CORE::bless [], 'YAML-anchor2node';
# }
# $self->inline('');
# while (length $preface) {
# my $line = $self->line - 1;
# if ($preface =~ s/^($FOLD_CHAR|$LIT_CHAR_RX)(-|\+)?\d*\s*//) {
# $indicator = $1;
# $chomp = $2 if defined($2);
# }
# else {
# $self->die('YAML_PARSE_ERR_TEXT_AFTER_INDICATOR') if $indicator;
# $self->inline($preface);
# $preface = '';
# }
# }
# if ($alias) {
# $self->die('YAML_PARSE_ERR_NO_ANCHOR', $alias)
# unless defined $self->anchor2node->{$alias};
# if (ref($self->anchor2node->{$alias}) ne 'YAML-anchor2node') {
# $node = $self->anchor2node->{$alias};
# }
# else {
# $node = do {my $sv = "*$alias"};
# push @{$self->anchor2node->{$alias}}, [\$node, $self->line];
# }
# }
# elsif (length $self->inline) {
# $node = $self->_parse_inline(1, $implicit, $explicit);
# if (length $self->inline) {
# $self->die('YAML_PARSE_ERR_SINGLE_LINE');
# }
# }
# elsif ($indicator eq $LIT_CHAR) {
# $self->{level}++;
# $node = $self->_parse_block($chomp);
# $node = $self->_parse_implicit($node) if $implicit;
# $self->{level}--;
# }
# elsif ($indicator eq $FOLD_CHAR) {
# $self->{level}++;
# $node = $self->_parse_unfold($chomp);
# $node = $self->_parse_implicit($node) if $implicit;
# $self->{level}--;
# }
# else {
# $self->{level}++;
# $self->offset->[$self->level] ||= 0;
# if ($self->indent == $self->offset->[$self->level]) {
# if ($self->content =~ /^-( |$)/) {
# $node = $self->_parse_seq($anchor);
# }
# elsif ($self->content =~ /(^\?|\:( |$))/) {
# $node = $self->_parse_mapping($anchor);
# }
# elsif ($preface =~ /^\s*$/) {
# $node = $self->_parse_implicit('');
script/_genpass-id view on Meta::CPAN
# $self->preface(defined($1) ? $1 : '');
# }
# else {
# $self->die('YAML_LOAD_ERR_BAD_SEQ_ELEMENT');
# }
#
# my $preface = $self->preface;
# if ( $preface =~ /^ (\s*) ( \w .*? \: (?:\ |$).*) $/x or
# $preface =~ /^ (\s*) ((') (?:''|[^'])*? ' \s* \: (?:\ |$).*) $/x or
# $preface =~ /^ (\s*) ((") (?:\\\\|[^"])*? " \s* \: (?:\ |$).*) $/x
# ) {
# $self->indent($self->offset->[$self->level] + 2 + length($1));
# $self->content($2);
# $self->level($self->level + 1);
# $self->offset->[$self->level] = $self->indent;
# $self->preface('');
# push @$seq, $self->_parse_mapping('');
# $self->{level}--;
# $#{$self->offset} = $self->level;
# }
# else {
# $self->_parse_next_line(COLLECTION);
# push @$seq, $self->_parse_node();
# }
# }
# return $seq;
#}
#
#sub _parse_inline {
# my $self = shift;
# my ($top, $top_implicit, $top_explicit) = (@_, '', '', '');
# $self->{inline} =~ s/^\s*(.*)\s*$/$1/;
# my ($node, $anchor, $alias, $explicit, $implicit) = ('') x 5;
# ($anchor, $alias, $explicit, $implicit, $self->{inline}) =
# $self->_parse_qualifiers($self->inline);
# if ($anchor) {
# $self->anchor2node->{$anchor} = CORE::bless [], 'YAML-anchor2node';
# }
# $implicit ||= $top_implicit;
# $explicit ||= $top_explicit;
# ($top_implicit, $top_explicit) = ('', '');
# if ($alias) {
# $self->die('YAML_PARSE_ERR_NO_ANCHOR', $alias)
# unless defined $self->anchor2node->{$alias};
# if (ref($self->anchor2node->{$alias}) ne 'YAML-anchor2node') {
# $node = $self->anchor2node->{$alias};
# }
# else {
# $node = do {my $sv = "*$alias"};
# push @{$self->anchor2node->{$alias}}, [\$node, $self->line];
# }
# }
# elsif ($self->inline =~ /^\{/) {
# $node = $self->_parse_inline_mapping($anchor);
# }
# elsif ($self->inline =~ /^\[/) {
# $node = $self->_parse_inline_seq($anchor);
# }
# elsif ($self->inline =~ /^"/) {
# $node = $self->_parse_inline_double_quoted();
# $node = $self->_unescape($node);
# $node = $self->_parse_implicit($node) if $implicit;
# }
# elsif ($self->inline =~ /^'/) {
# $node = $self->_parse_inline_single_quoted();
# $node = $self->_parse_implicit($node) if $implicit;
# }
# else {
# if ($top) {
# $node = $self->inline;
# $self->inline('');
# }
# else {
# $node = $self->_parse_inline_simple();
# }
# $node = $self->_parse_implicit($node) unless $explicit;
#
# if ($self->numify and defined $node and not ref $node and length $node
# and $node =~ m/\A-?(?:0|[1-9][0-9]*)?(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?\z/) {
# $node += 0;
# }
# }
# if ($explicit) {
# $node = $self->_parse_explicit($node, $explicit);
# }
# if ($anchor) {
# if (ref($self->anchor2node->{$anchor}) eq 'YAML-anchor2node') {
# for my $ref (@{$self->anchor2node->{$anchor}}) {
# ${$ref->[0]} = $node;
# $self->warn('YAML_LOAD_WARN_UNRESOLVED_ALIAS',
# $anchor, $ref->[1]);
# }
# }
# $self->anchor2node->{$anchor} = $node;
# }
# return $node;
#}
#
#sub _parse_inline_mapping {
# my $self = shift;
# my ($anchor) = @_;
# my $node = {};
# $self->anchor2node->{$anchor} = $node;
#
# $self->die('YAML_PARSE_ERR_INLINE_MAP')
# unless $self->{inline} =~ s/^\{\s*//;
# while (not $self->{inline} =~ s/^\s*\}\s*//) {
# my $key = $self->_parse_inline();
# $self->die('YAML_PARSE_ERR_INLINE_MAP')
# unless $self->{inline} =~ s/^\: \s*//;
# my $value = $self->_parse_inline();
# if (exists $node->{$key}) {
# $self->warn('YAML_LOAD_WARN_DUPLICATE_KEY', $key);
# }
# else {
# $node->{$key} = $value;
# }
# next if $self->inline =~ /^\s*\}/;
# $self->die('YAML_PARSE_ERR_INLINE_MAP')
# unless $self->{inline} =~ s/^\,\s*//;
# }
script/_genpass-id view on Meta::CPAN
# $self->offset->[$level+1] = $offset + 1;
# return;
# }
# else {
# $self->lines->[0] =~ /^( *)\S/ or
# $self->die('YAML_PARSE_ERR_NONSPACE_INDENTATION');
# if (length($1) > $offset) {
# $self->offset->[$level+1] = length($1);
# }
# else {
# $self->offset->[$level+1] = $offset + 1;
# }
# }
# $offset = $self->offset->[++$level];
# }
#
# if ($type == LEAF) {
# while (@{$self->lines} and
# $self->lines->[0] =~ m{^( *)(\#)} and
# length($1) < $offset
# ) {
# shift @{$self->lines};
# $self->{line}++;
# }
# $self->eos($self->{done} = not @{$self->lines});
# }
# else {
# $self->_parse_throwaway_comments();
# }
# return if $self->eos;
#
# if ($self->lines->[0] =~ /^---(\s|$)/) {
# $self->done(1);
# return;
# }
# if ($type == LEAF and
# $self->lines->[0] =~ /^ {$offset}(.*)$/
# ) {
# $self->indent($offset);
# $self->content($1);
# }
# elsif ($self->lines->[0] =~ /^\s*$/) {
# $self->indent($offset);
# $self->content('');
# }
# else {
# $self->lines->[0] =~ /^( *)(\S.*)$/;
# while ($self->offset->[$level] > length($1)) {
# $level--;
# }
# $self->die('YAML_PARSE_ERR_INCONSISTENT_INDENTATION')
# if $self->offset->[$level] != length($1);
# $self->indent(length($1));
# $self->content($2);
# }
# $self->die('YAML_PARSE_ERR_INDENTATION')
# if $self->indent - $offset > 1;
#}
#
#
#my %unescapes = (
# 0 => "\x00",
# a => "\x07",
# t => "\x09",
# n => "\x0a",
# 'v' => "\x0b",
# f => "\x0c",
# r => "\x0d",
# e => "\x1b",
# '\\' => '\\',
# );
#
#sub _unescape {
# my $self = shift;
# my ($node) = @_;
# $node =~ s/\\([never\\fart0]|x([0-9a-fA-F]{2}))/
# (length($1)>1)?pack("H2",$2):$unescapes{$1}/gex;
# return $node;
#}
#
#1;
### YAML/Old/Loader/Base.pm ###
#package YAML::Old::Loader::Base;
#
#use YAML::Old::Mo;
#
#has load_code => default => sub {0};
#has preserve => default => sub {0};
#has stream => default => sub {''};
#has document => default => sub {0};
#has line => default => sub {0};
#has documents => default => sub {[]};
#has lines => default => sub {[]};
#has eos => default => sub {0};
#has done => default => sub {0};
#has anchor2node => default => sub {{}};
#has level => default => sub {0};
#has offset => default => sub {[]};
#has preface => default => sub {''};
#has content => default => sub {''};
#has indent => default => sub {0};
#has major_version => default => sub {0};
#has minor_version => default => sub {0};
#has inline => default => sub {''};
#has numify => default => sub {0};
#
#sub set_global_options {
# my $self = shift;
# $self->load_code($YAML::LoadCode || $YAML::UseCode)
# if defined $YAML::LoadCode or defined $YAML::UseCode;
# $self->preserve($YAML::Preserve) if defined $YAML::Preserve;
# $self->numify($YAML::Numify) if defined $YAML::Numify;
#}
#
#sub load {
# die 'load() not implemented in this class.';
#}
#
#1;
### YAML/Old/Marshall.pm ###
#use strict; use warnings;
#package YAML::Old::Marshall;
#
#use YAML::Old::Node ();
#
#sub import {
# my $class = shift;
# no strict 'refs';
# my $package = caller;
# unless (grep { $_ eq $class} @{$package . '::ISA'}) {
# push @{$package . '::ISA'}, $class;
# }
#
# my $tag = shift;
# if ( $tag ) {
# no warnings 'once';
# $YAML::TagClass->{$tag} = $package;
( run in 2.007 seconds using v1.01-cache-2.11-cpan-59e3e3084b8 )