YAML-PP

 view release on metacpan or  search on metacpan

bin/yamlpp-load  view on Meta::CPAN

    'perl' => \my $perl,
    'module|M=s' => \my $module,
    'yaml-version=s' => \my $yaml_version,
) or usage(1);

usage(0) if $help;

$module ||= 'YAML::PP';
$boolean ||= 'JSON::PP';
$yaml_version ||= 1.2;
my @yaml_versions = split m/,/, $yaml_version;
my @schema = ('+');
if ($merge) {
    push @schema, 'Merge';
}
if ($perl) {
    push @schema, 'Perl';
}
#if ($catchall) {
#    push @schema, 'Catchall';
#}

bin/yamlpp-load-dump  view on Meta::CPAN

$module ||= 'YAML::PP';
$boolean ||= 'JSON::PP';
$footer ||= 0;
$indent ||= 2;
$yaml_version ||= 1.2;
$dump_module ||= $module;
if ($dump_module eq 'YAML::PP::Ref') {
    $dump_module = 'YAML::PP';
}
my @yaml_versions = split m/,/, $yaml_version;
my @schema = ('+');
if ($merge) {
    push @schema, 'Merge';
}
if ($perl) {
    push @schema, 'Perl';
}
#if ($catchall) {
#    push @schema, 'Catchall';
#}

my $preserve_order = 1;
if (defined $preserve) {
    $preserve_order = 0;
    my @split = split m/,/, $preserve;
    $preserve = 0;
    for my $split (@split) {
        $preserve |= PRESERVE_ORDER if $split eq 'order';
        $preserve_order = 1 if $split eq 'order';
        $preserve |= PRESERVE_SCALAR_STYLE if $split eq 'scalar';
        $preserve |= PRESERVE_FLOW_STYLE if $split eq 'flow';
        $preserve |= PRESERVE_ALIAS if $split eq 'alias';
    }
}
elsif ($dump_module =~ m/JSON/) {

etc/generate-schema-html.pl  view on Meta::CPAN

my $modules = YAML::PP::LoadFile($modulesfile);
my @mods = qw/ YAML YAML::Syck YAML::XS /;

my %examples;

for my $input (sort keys %$data) {
    my $schemas = $data->{ $input };
    my @keys = keys %$schemas;
    for my $key (@keys) {
        my $def = $schemas->{ $key };
        my @schemas = split m/ *, */, $key;
        for my $schema (@schemas) {
            $examples{ $input }->{ $schema } = $def;
        }
    }
}
my @keys = qw/ failsafe json core yaml11 /;
for my $input (sort keys %examples) {
    my $schemas = $examples{ $input };
    my $str = 0;
    for my $schema (@keys) {

ext/yaml-test-schema/etc/generate-schema-html.pl  view on Meta::CPAN

my $data = YAML::PP::LoadFile($file);

my %examples;

for my $input (sort keys %$data) {
    my $schemas = $data->{ $input };
    my @keys = keys %$schemas;
    for my $key (@keys) {
        my $def = $schemas->{ $key };
        my @schemas = split m/ *, */, $key;
        for my $schema (@schemas) {
            $examples{ $input }->{ $schema } = $def;
        }
    }
}
my @keys = qw/ failsafe json core yaml11 /;
for my $input (sort keys %examples) {
    my $schemas = $examples{ $input };
    my $str = 0;
    for my $schema (@keys) {

lib/YAML/PP/Dumper.pm  view on Meta::CPAN

    $self->emitter->init;

    $self->emitter->stream_start_event({});

    for my $i (0 .. $#docs) {
        my $header_implicit = ($i == 0 and not $self->header);
        my %args = (
            implicit => $header_implicit,
        );
        if ($self->version_directive) {
            my ($major, $minor) = split m/\./, $self->representer->schema->yaml_version;
            $args{version_directive} = { major => $major, minor => $minor };
        }
        $self->emitter->document_start_event( \%args );
        $self->init;
        $self->_check_references($docs[ $i ]);
        $self->_dump_node($docs[ $i ]);
        my $footer_implicit = (not $self->footer);
        $self->emitter->document_end_event({ implicit => $footer_implicit });
    }

lib/YAML/PP/Emitter.pm  view on Meta::CPAN

    );

    my $open_ended = 0;

    if ($style == YAML_PLAIN_SCALAR_STYLE) {
        $value =~ s/\n/\n\n/g;
    }
    elsif ($style == YAML_SINGLE_QUOTED_SCALAR_STYLE) {
        my $new_indent = $last->{indent} . (' ' x $self->indent);
        $value =~ s/(\n+)/"\n" x (1 + (length $1))/eg;
        my @lines = split m/\n/, $value, -1;
        if (@lines > 1) {
            for my $line (@lines[1 .. $#lines]) {
                $line = $new_indent . $line
                    if length $line;
            }
        }
        $value = join "\n", @lines;
        $value =~ s/'/''/g;
        $value = "'" . $value . "'";
    }

lib/YAML/PP/Emitter.pm  view on Meta::CPAN

}

sub finish {
    my ($self) = @_;
    $self->writer->finish;
}

sub _write {
    my ($self, $yaml) = @_;
    return unless length $yaml;
    my @lines = split m/\n/, $yaml, -1;
    my $newlines = @lines - 1;
    $self->{line} += $newlines;
    if (length $lines[-1]) {
        if ($newlines) {
            $self->{column} = length $lines[-1];
        }
        else {
            $self->{column} += length $lines[-1];
        }
    }

lib/YAML/PP/Highlight.pm  view on Meta::CPAN

        for my $token (@values) {
            my $value = defined $token->{orig} ? $token->{orig} : $token->{value};
            if ($token->{name} eq 'EOL' and not length $value) {
                push @list, { name => 'NOEOL', value => '' };
                next;
            }
            push @list, map {
                    $_ =~ tr/\t/\t/
                    ? { name => 'TAB', value => $_ }
                    : { name => $token->{name}, value => $_ }
                } split m/(\t+)/, $value;
        }
    }
    for my $i (0 .. $#list) {
        my $token = $list[ $i ];
        my $name = $token->{name};
        my $str = $token->{value};
        my $trailing_space = 0;
        if ($token->{name} eq 'EOL') {
            if ($str =~ m/ +([\r\n]|\z)/) {
                $token->{name} = "TRAILING_SPACE";

lib/YAML/PP/Parser.pm  view on Meta::CPAN

    });
}

sub start_document {
    my ($self, $implicit) = @_;
    push @{ $self->events }, 'DOC';
    push @{ $self->offset }, -1;
    my $directive = $self->yaml_version_directive;
    my %directive;
    if ($directive) {
        my ($major, $minor) = split m/\./, $self->yaml_version;
        %directive = ( version_directive => { major => $major, minor => $minor } );
    }
    $self->callback->($self, 'document_start_event', {
        name => 'document_start_event',
        implicit => $implicit,
        %directive,
    });
    $self->set_yaml_version_directive(undef);
    $self->set_rule( 'FULLNODE' );
    $self->set_new_node(1);

lib/YAML/PP/Schema.pm  view on Meta::CPAN

    my $yaml_version = delete $args{yaml_version};
    my $bool = delete $args{boolean};
    $bool = 'perl' unless defined $bool;
    if (keys %args) {
        die "Unexpected arguments: " . join ', ', sort keys %args;
    }
    my $true;
    my $false;
    my @bool_class;
    my @bools = split m/,/, $bool;
    for my $b (@bools) {
        if ($b eq '*') {
            push @bool_class, ('boolean', 'JSON::PP::Boolean');
            last;
        }
        elsif ($b eq 'JSON::PP') {
            require JSON::PP;
            $true ||= \&_bool_jsonpp_true;
            $false ||= \&_bool_jsonpp_false;
            push @bool_class, 'JSON::PP::Boolean';

lib/YAML/PP/Schema/Perl.pm  view on Meta::CPAN

            if ($option =~ m/^tags?=(.+)$/) {
                $tagtype = $1;
            }
            elsif ($option eq '+loadcode') {
                $loadcode = 1;
            }
            elsif ($option eq '-dumpcode') {
                $dumpcode = 0;
            }
        }
        $tags = [split m/\+/, $tagtype];
    }


    my $perl_tag;
    my %tagtypes;
    my @perl_tags;
    for my $type (@$tags) {
        if ($type eq '!perl') {
            $perl_tag ||= $type;
            push @perl_tags, '!perl';

lib/YAML/PP/Schema/YAML1_1.pm  view on Meta::CPAN

    $result = -$result if $sign eq '-';
    return $result;
}
sub _sexa_to_float {
    my ($constructor, $event, $matches) = @_;
    my ($float) = @$matches;
    my $result = 0;
    my $i = 0;
    my $sign = 1;
    $float =~ s/^-// and $sign = -1;
    for my $part (reverse split m/:/, $float) {
        $result += $part * ( 60 ** $i );
        $i++;
    }
    $result = unpack F => pack F => $result;
    return $result * $sign;
}
sub _to_float {
    my ($constructor, $event, $matches) = @_;
    my ($float) = @$matches;
    $float =~ tr/_//d;

t/31.schema.t  view on Meta::CPAN

    );
}

my $i = 0;
for my $input (sort keys %$schema_data) {
    my $test_data = $schema_data->{ $input };
#    note("Input: $input");

    for my $schema_names (sort keys %$test_data) {
        note("[$input] Schemas: " . $schema_names);
        my @names = split m/ *, */, $schema_names;
        my $test = $test_data->{ $schema_names };
        for my $name (@names) {
            my $yp = $loaders{ $name };
            my %def;
            @def{ qw/ type data dump /} = @$test;
            next if ($def{type} eq 'bool' and not $jsonpp);
            my $func;
            my $data = $yp->load_string('--- ' . $input);
            my $data_orig = $data; # avoid stringifying original data

t/lib/YAML/PP/Test.pm  view on Meta::CPAN

    my ($self, $testcase, $result) = @_;
    my $stats = $self->{stats};
    my $id = $testcase->{id};
    my $title = $testcase->{title};
    my $err = $result->{err};
    my $yaml = $testcase->{in_yaml};
    my $exp_json = $testcase->{in_json};
    my $docs = $result->{data};

    # input can contain multiple JSON
    my @exp_json = split m/^(?=true|false|null|[0-9"\{\[])/m, $exp_json;
    $exp_json = '';
    my $coder = JSON::PP->new->ascii->pretty->allow_nonref->canonical;
    for my $exp (@exp_json) {
        my $data = $coder->decode($exp);
        $exp = $coder->encode($data);
        $exp_json .= $exp;
    }

    my $json = '';
    for my $doc (@$docs) {