view release on metacpan or  search on metacpan

script/rrjson.pl  view on Meta::CPAN

my $prp;
my $combined_keys;
my $implied_outer_hash;

my $verbose = 1;		# verbose processing

# Development options (not shown with -help).
my $pretoks = 0;
my $tokens = 0;
my $debug = 0;			# debugging
my $trace = 0;			# trace (show process)
my $test = 0;			# test mode.

my $have_yaml = eval { require YAML::PP };
my $have_toml = eval { require TOML::Tiny };

# Process command line options.
app_options();

# Post-processing.

# Default is non-strict.
$strict //= 0;
if ( $strict ) {
    # No extensions.
    $order                = 0;
    $prp                  = 0;
    $combined_keys        = 0;
    $implied_outer_hash   = 0;
}
else {
    # Default is all extensions.
    $order              //= 1;
    $prp                //= 1;
    $combined_keys      //= 1;
    $implied_outer_hash //= 1;
}

$trace |= ($debug || $test);

################ Presets ################

# For conditional filling of hashes.
sub maybe ( $key, $value, @rest ) {
    if (defined $key and defined $value) {
	return ( $key, $value, @rest );
    }
    else {
	( defined($key) || @rest ) ? @rest : ();
    }
}

################ The Process ################

use FindBin;
use lib "$FindBin::Bin/../lib";
use JSON::Relaxed;
use JSON::PP;
use File::LoadLines;
use Encode qw(decode_utf8);
binmode STDOUT => ':utf8';
binmode STDERR => ':utf8';

if ( $schema ) {
    my $parser = JSON::Relaxed::Parser->new( strict => 0 );
    my $data = loadlines( $schema, { split => 0 } );
    $data = $parser->decode($data);
    warn("Schema $schema loaded\n") if $verbose;
    $schema = $data;
}

my $parser = JSON::Relaxed::Parser->new
  ( booleans		  => [ $JSON::PP::false, $JSON::PP::true ],
    strict	          => $strict,
    prp		          => $prp,
    combined_keys	  => $combined_keys,
    implied_outer_hash    => $implied_outer_hash,
    prp		          => $prp,
    pretty	          => $pretty,
    key_order	          => $order && $mode !~ /^json/,
    maybe croak_on_error  => $croak_on_error,
    maybe extra_tokens_ok => $extra_tokens_ok,
    );

if ( $mode eq "dumper" ) {
    $parser->booleans = [0,1];
}

if ( $verbose > 1 ) {
    my @opts;
    for ( qw( strict pretty prp combined_keys implied_outer_hash
	      croak_on_error extra_tokens_ok booleans ) ) {
	push( @opts, $_ ) if $parser->$_;
    }
    if ( @opts ) {
	warn( "Parser options: ", join(", ", @opts), ".\n");
    }

}

for my $file ( @ARGV ) {

    my $json;
    my $prp;
    if ( $execute ) {
	$json = decode_utf8($file);
    }
    else {
	$prp = $file =~ /\.prp$/i;
	my $opts = { split => 1, fail => "soft" };
	$json = loadlines( $file, $opts );
	die( "$file: $opts->{error}\n") if $opts->{error};
	$json = join( "\n", @$json, '' ) unless $prp;
	if ( ($pretoks || $tokens) && $file !~ /\.r?r?json$/i ) {
	    warn( "$file: not JSON data, ignoring tokens\n" );
	}
    }

    my $data;

    # For debugging/development.
    if ( ( $pretoks || $tokens ) && !$prp ) {