Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

223 lines (202 sloc) 6.439 kb
use strict; use warnings;
package JSYNC;
our $VERSION = '0.25';
use JSON;
{
package JSYNC;
sub dump {
my ($object, $config) = @_;
$config ||= {};
return JSYNC::Dumper->new(%$config)->dump($object);
}
sub load {
my ($jsync) = @_;
return JSYNC::Loader->new->load($jsync);
}
sub info {
my ($kind, $id, $class);
if (ref(\$_[0]) eq 'GLOB') {
(\$_[0] . "") =~ /^(?:(.+)=)?(GLOB)\((0x.*)\)$/
or die "Can't get info for '$_[0]'";
($kind, $id, $class) = ('glob', $3, $1 || '');
}
elsif (not ref($_[0])) {
$kind = 'scalar';
}
else {
"$_[0]" =~ /^(?:(.+)=)?(HASH|ARRAY)\((0x.*)\)$/
or die "Can't get info for '$_[0]'";
($kind, $id, $class) =
(($2 eq 'HASH' ? 'map' : 'seq'), $3, $1 || '');
}
return ($kind, $id, $class);
}
};
{
package JSYNC::Dumper;
sub new { bless { @_[1..$#_] }, $_[0] }
sub dump {
my ($self, $object) = @_;
$self->{anchor} = 1;
$self->{seen} = {};
my $graph = $self->represent($object);
my $json = 'JSON'->new()->canonical();
$json->pretty() if $self->{pretty};
return $json->encode($graph);
}
sub represent {
my ($self, $node) = @_;
my $seen = $self->{seen};
my $graph;
my ($kind, $id, $class) = JSYNC::info($node);
if ($kind eq 'scalar') {
if (not defined $node) {
return undef;
}
return $self->escape($node);
}
if (my $info = $seen->{$id}) {
if (not $info->{anchor}) {
$info->{anchor} = $self->{anchor}++ . "";
if ($info->{kind} eq 'map') {
$info->{graph}{'&'} = $info->{anchor};
}
else {
unshift @{$info->{graph}}, '&' . $info->{anchor};
}
}
return "*" . $info->{anchor};
}
my $tag = $self->resolve_to_tag($kind, $class);
if ($kind eq 'seq') {
$graph = [];
$seen->{$id} = { graph => $graph, kind => $kind };
@$graph = map { $self->represent($_) } @$node;
if ($tag) {
unshift @$graph, "!$tag";
}
}
elsif ($kind eq 'map') {
$graph = {};
$seen->{$id} = { graph => $graph, kind => $kind };
for my $k (keys %$node) {
$graph->{$self->represent($k)} = $self->represent($node->{$k});
}
if ($tag) {
$graph->{'!'} = $tag;
}
}
# XXX glob should not be a kind.
elsif ($kind eq 'glob') {
$class ||= 'main';
$graph = {};
$graph->{PACKAGE} = $class;
$graph->{'!'} = '!perl/glob:';
for my $type (qw(PACKAGE NAME SCALAR ARRAY HASH CODE IO)) {
my $value = *{$node}{$type};
$value = $$value if $type eq 'SCALAR';
if (defined $value) {
if ($type eq 'IO') {
my @stats = qw(device inode mode links uid gid rdev size
atime mtime ctime blksize blocks);
undef $value;
$value->{stat} = {};
map {$value->{stat}{shift @stats} = $_} stat(*{$node});
$value->{fileno} = fileno(*{$node});
{
local $^W;
$value->{tell} = tell(*{$node});
}
}
$graph->{$type} = $value;
}
}
}
else {
# XXX [$id, $kind, $class];
die "Can't represent kind '$kind'";
}
return $graph;
}
sub escape {
my ($self, $string) = @_;
$string =~ s/^(\.*[\!\&\*\%])/.$1/;
return $string;
}
my $perl_type = {
map => 'hash',
seq => 'array',
scalar => 'scalar',
};
sub resolve_to_tag {
my ($self, $kind, $class) = @_;
return $class && "!perl/$perl_type->{$kind}\:$class";
}
};
{
package JSYNC::Loader;
sub new { bless { @_[1..$#_] }, $_[0] }
sub load {
my ($self, $jsync) = @_;
$self->{seen} = {};
my $graph = 'JSON'->new()->decode($jsync);
return $self->construct($graph);
}
sub construct {
my ($self, $graph) = @_;
my $seen = $self->{seen};
my $node;
my ($kind, $id, $class) = JSYNC::info($graph);
if ($kind eq 'scalar') {
if (not defined $graph) {
return undef;
}
if ($graph =~ /^\*(\S+)$/) {
return $seen->{$1};
}
return $self->unescape($graph);
}
if ($kind eq 'map') {
$node = {};
if ($graph->{'&'}) {
my $anchor = $graph->{'&'};
delete $graph->{'&'};
$seen->{$anchor} = $node;
}
if ($graph->{'!'}) {
my $class = $self->resolve_from_tag($graph->{'!'});
delete $graph->{'!'};
bless $node, $class;
}
for my $k (keys %$graph) {
$node->{$self->unescape($k)} = $self->construct($graph->{$k});
}
}
elsif ($kind eq 'seq') {
$node = [];
if (@$graph and defined $graph->[0] and $graph->[0] =~ /^!(.*)$/) {
my $class = $self->resolve_from_tag($1);
shift @$graph;
bless $node, $class;
}
if (@$graph and $graph->[0] and $graph->[0] =~ /^\&(\S+)$/) {
$seen->{$1} = $node;
shift @$graph;
}
@$node = map {$self->construct($_)} @$graph;
}
return $node;
}
sub unescape {
my ($self, $string) = @_;
$string =~ s/^\.(\.*[\!\&\*\%])/$1/;
return $string;
}
sub resolve_from_tag {
my ($self, $tag) = @_;
$tag =~ m{^!perl/(?:hash|array|object):(\S+)$}
or die "Can't resolve tag '$tag'";
return $1;
}
};
1;
Jump to Line
Something went wrong with that request. Please try again.