CPAN::Groonga

package Venus::Json;

use 5.018;

use strict;
use warnings;

use overload (
  '""' => 'explain',
  '~~' => 'explain',
  fallback => 1,
);

use Venus::Class 'attr', 'base', 'with';

base 'Venus::Kind::

($package->can('escape_slash')) {
    $package->escape_slash;
  }

  # Cpanel::JSON::XS
  if ($package->isa('Cpanel::JSON::XS')) {
    $self->decoder(sub {
      my ($text) = @_;
      $package->decod

coder(sub {
      my ($data) = @_;
      $package->encode($data);
    });
  }

  # JSON::XS
  if ($package->isa('JSON::XS')) {
    $self->decoder(sub {
      my ($text) = @_;
      $package->decode($t

s) = @_;

  return $self->printer($self->dump(@args));
}

sub print_json {
  my ($self, $method, @args) = @_;

  require Venus::Json;

  my $value = $method ? scalar($self->$method(@args)) : $self;

 

) {
    $value = $value->value if $value->isa('Venus::Kind');
  }

  return $self->printer(Venus::Json->new($value)->encode);
}

sub print_pretty {
  my ($self, @args) = @_;

  return $self->printer($

 @_;

  return $self->printer($self->dump(@args), "\n");
}

sub say_json {
  my ($self, $method, @args) = @_;

  require Venus::Json;

  my $value = $method ? scalar($self->$method(@args)) : $self;

 

$base = $FILE =~ s/\.\w+$//r;

  return $ENV{VENUS_FILE} || (grep -f, map "$base.$_", qw(yaml yml json js perl pl))[0]
}

state $footer = <<"EOF";
Config:

Here is an example configuration in YAML (e.

N

auto Venus::Run sub {
  my ($self) = @_;

  my $tryer = $self->tryer;

  $tryer->catch('Venus::Json::Error', sub {
    $self->log_error($_->render);
  });

  $tryer->catch('Venus::Path::Error', sub

 conf example 5

  # given: synopsis

  package main;

  # e.g. current directory has only a .vns.json file

  my $conf = $run->conf;

  # {...}

=back

=over 4

=item conf example 6

  # given: synop

     local $YAML::XS::Boolean = 'JSON::PP';
      YAML::XS::Load($text);
    });
    $self->encoder(sub {
      my ($data) = @_;
      local $YAML::XS::Boolean = 'JSON::PP';
      YAML::XS::Dump($data

= @_;
      YAML::PP->new(boolean => 'JSON::PP')->load_string($text);
    });
    $self->encoder(sub {
      my ($data) = @_;
      YAML::PP->new(boolean => 'JSON::PP')->dump_string($data);
    });
  

= @_;
      YAML::PP->new(boolean => 'JSON::PP')->load_string($text);
    });
    $self->encoder(sub {
      my ($data) = @_;
      YAML::PP->new(boolean => 'JSON::PP')->dump_string($data);
    });
  

read_json_file',
  json => 'read_json_file',
  perl => 'read_perl_file',
  pl => 'read_perl_file',
  yaml => 'read_yaml_file',
  yml => 'read_yaml_file',
};

state $writer = {
  js => 'write_json_file

',
  json => 'write_json_file',
  perl => 'write_perl_file',
  pl => 'write_perl_file',
  yaml => 'write_yaml_file',
  yml => 'write_yaml_file',
};

# BUILDERS

sub build_args {
  my ($self, $data) = 

elf->class->new;
  }
}

sub read_json {
  my ($self, $data) = @_;

  require Venus::Json;

  return $self->class->new(Venus::Json->new->decode($data));
}

sub read_json_file {
  my ($self, $file) = @_

ub mutate {
  my ($self, $code, @args) = @_;

  return $self->set($self->$code(@args));
}

sub TO_JSON {
  my ($self) = @_;

  return $self->get;
}

1;



=head1 NAME

Venus::Kind::Value - Value Base 

my ($value) = @_;

  require JSON::PP;

  my $isdual = Scalar::Util::isdual($value);

  if ($isdual && ("$value" && "$value" == "1" && ($value + 0) == 1)) {
    return JSON::PP::true();
  }
  elsif ($

isdual && (("$value" eq "") || ("$value" == "0" && ($value + 0) == 0))) {
    return JSON::PP::false();
  }
  else {
    return $value;
  }
}

sub TO_BOOL_TFO {
  my ($value) = @_;

  my $isdual = Sca

$value + 0) == 0))) {
    return Venus::False->new;
  }
  else {
    return $value;
  }
}

sub TO_JSON {
  my ($self) = @_;

  no strict 'refs';

  return $self->get ? $true_ref : $false_ref;
}

sub T

=> 1,
    hash => 1,
    hashref => 1,
    is_bool => 1,
    is_false => 1,
    is_true => 1,
    json => 1,
    list => 1,
    load => 1,
    log => 1,
    make => 1,
    match => 1,
    merge => 1,

>is_true;
}

sub json (;$$) {
  my ($code, $data) = @_;

  require Venus::Json;

  if (!$code) {
    return Venus::Json->new;
  }

  if (lc($code) eq 'decode') {
    return Venus::Json->new->decode($d

ata);
  }

  if (lc($code) eq 'encode') {
    return Venus::Json->new(value => $data)->encode;
  }

  return fault(qq(Invalid "json" action "$code"));
}

sub list (@) {
  my (@args) = @_;

  return ma