[ViewVC] Annotation of: cvs/cvsroot/JSON-XS/bin/json_xs

#!/opt/bin/perl

=head1 NAME

json_xs - JSON::XS commandline utility

=head1 SYNOPSIS

   json_xs [-v] [-f inputformat] [-t outputformat]

=head1 DESCRIPTION

F<json_xs> converts between some input and output formats (one of them is
JSON).

The default input format is C<json> and the default output format is
C<json-pretty>.

=head1 OPTIONS

=over 4

=item -v

Be slightly more verbose.

=item -f fromformat

Read a file in the given format from STDIN.

C<fromformat> can be one of:

=over 4

=item json - a json text encoded, either utf-8, utf16-be/le, utf32-be/le

=item storable - a Storable frozen value

=item storable-file - a Storable file (Storable has two incompatible formats)

=item clzf - Compress::LZF format (requires that module to be installed)

=item yaml - YAML (avoid at all costs, requires the YAML module :)

=back

=item -t toformat

Write the file in the given format to STDOUT.

C<toformat> can be one of:

=over 4

=item json, json-utf-8 - json, utf-8 encoded

=item json-pretty - as above, but pretty-printed

=item json-utf-16le, json-utf-16be - little endian/big endian utf-16

=item json-utf-32le, json-utf-32be - little endian/big endian utf-32

=item storable - a Storable frozen value in network format

=item storable-file - a Storable file in network format (Storable has two incompatible formats)

=item clzf - Compress::LZF format

=item yaml - YAML

=item dump - Data::Dump

=item dumper - Data::Dumper

=back

=back

=head1 EXAMPLES

   json_xs -t null <isitreally.json

"JSON Lint" - tries to parse the file F<isitreally.json> as JSON - if it
is valid JSON, the command outputs nothing, otherwise it will print an
error message and exit with non-zero exit status.

   <src.json json_xs >pretty.json

Prettify the JSON file F<src.json> to F<dst.json>.

   json_xs -f storable-file <file

Read the serialised Storable file F<file> and print a human-readable JSON
version of it to STDOUT.

   json_xs -f storable-file -t yaml <file

Same as above, but write YAML instead (not using JSON at all :)

   lwp-request http://cpantesters.perl.org/show/JSON-XS.json | json_xs

Fetch the cpan-testers result summary C<JSON::XS> and pretty-print it.

=head1 AUTHOR

Copyright (C) 2008 Marc Lehmann <json@schmorp.de>

=cut

use strict;

use Getopt::Long;
use Storable ();
use Encode;

use JSON::XS;

my $opt_verbose;
my $opt_from = "json";
my $opt_to   = "json-pretty";

Getopt::Long::Configure ("bundling", "no_ignore_case", "require_order");

GetOptions(
   "v"   => \$opt_verbose,
   "f=s" => \$opt_from,
   "t=s" => \$opt_to,
) or die "Usage: $0 [-v] -f fromformat [-t toformat]\n";

my %F = (
   "json"          => sub {
      my $enc =
         /^\x00\x00\x00/s  ? "utf-32be"
       : /^\x00.\x00/s     ? "utf-16be"
       : /^.\x00\x00\x00/s ? "utf-32le"
       : /^.\x00.\x00/s    ? "utf-16le"
       :                     "utf-8";
      warn "input text encoding is $enc\n" if $opt_verbose;
      JSON::XS->new->decode (decode $enc, $_)
   },
   "storable"      => sub { Storable::thaw $_ },
   "storable-file" => sub { open my $fh, "<", \$_; Storable::fd_retrieve $fh },
   "clzf"          => sub { require Compress::LZF; Compress::LZF::sthaw ($_) },
   "yaml"          => sub { require YAML; YAML::Load ($_) },
);

my %T = (
   "null"          => sub { "" },
   "json"          => sub { encode_json $_ },
   "json-utf-8"    => sub { encode_json $_ },
   "json-pretty"   => sub { JSON::XS->new->utf8->pretty->encode ($_) },
   "json-utf-16le" => sub { encode "utf-16le", JSON::XS->new->encode ($_) },
   "json-utf-16be" => sub { encode "utf-16be", JSON::XS->new->encode ($_) },
   "json-utf-32le" => sub { encode "utf-32le", JSON::XS->new->encode ($_) },
   "json-utf-32be" => sub { encode "utf-32be", JSON::XS->new->encode ($_) },

   "storable"      => sub { Storable::nfreeze $_ },
   "storable-file" => sub { open my $fh, ">", \my $buf; Storable::nstore_fd $_, $fh; $buf },

   "clzf"          => sub { require Compress::LZF; Compress::LZF::sfreeze_cr ($_) },
   "yaml"          => sub { require YAML; YAML::Dump ($_) },
   "dumper"        => sub {
      require Data::Dumper;
      local $Data::Dumper::Terse     = 1;
      local $Data::Dumper::Indent    = 1;
      local $Data::Dumper::Useqq     = 1;
      local $Data::Dumper::Quotekeys = 0;
      local $Data::Dumper::Sortkeys  = 1;
      Data::Dumper::Dumper($_)
   },
   "dump"          => sub {
      require Data::Dump;
      local $Data::Dump::TRY_BASE64 = 0;
      Data::Dump::dump ($_) . "\n"
   },
);

$F{$opt_from}
   or die "$opt_from: not a valid fromformat\n";

$T{$opt_to}
   or die "$opt_from: not a valid toformat\n";

{
   local $/;
   binmode STDIN; # stupid perl sometimes thinks its funny
   $_ = <STDIN>;
}

$_ = $F{$opt_from}->();
$_ = $T{$opt_to}->();

binmode STDOUT;
print $_;


Revision:	1.7
Committed:	Fri Aug 13 21:03:17 2010 UTC (16 years, 2 months ago) by root
Branch:	MAIN
Changes since 1.6:	+5 -1 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#!/opt/bin/perl
2
3			=head1 NAME
4
5			json_xs - JSON::XS commandline utility
6
7			=head1 SYNOPSIS
8
9			json_xs [-v] [-f inputformat] [-t outputformat]
10
11			=head1 DESCRIPTION
12
13			F<json_xs> converts between some input and output formats (one of them is
14			JSON).
15
16			The default input format is C<json> and the default output format is
17			C<json-pretty>.
18
19			=head1 OPTIONS
20
21			=over 4
22
23			=item -v
24
25			Be slightly more verbose.
26
27			=item -f fromformat
28
29			Read a file in the given format from STDIN.
30
31			C<fromformat> can be one of:
32
33			=over 4
34
35			=item json - a json text encoded, either utf-8, utf16-be/le, utf32-be/le
36
37			=item storable - a Storable frozen value
38
39			=item storable-file - a Storable file (Storable has two incompatible formats)
40
41	root	1.4	=item clzf - Compress::LZF format (requires that module to be installed)
42	root	1.1
43			=item yaml - YAML (avoid at all costs, requires the YAML module :)
44
45			=back
46
47			=item -t toformat
48
49			Write the file in the given format to STDOUT.
50
51	root	1.6	C<toformat> can be one of:
52	root	1.1
53			=over 4
54
55			=item json, json-utf-8 - json, utf-8 encoded
56
57			=item json-pretty - as above, but pretty-printed
58
59			=item json-utf-16le, json-utf-16be - little endian/big endian utf-16
60
61			=item json-utf-32le, json-utf-32be - little endian/big endian utf-32
62
63			=item storable - a Storable frozen value in network format
64
65			=item storable-file - a Storable file in network format (Storable has two incompatible formats)
66
67			=item clzf - Compress::LZF format
68
69			=item yaml - YAML
70
71	root	1.6	=item dump - Data::Dump
72
73			=item dumper - Data::Dumper
74
75	root	1.1	=back
76
77			=back
78
79			=head1 EXAMPLES
80
81	root	1.2	json_xs -t null <isitreally.json
82
83			"JSON Lint" - tries to parse the file F<isitreally.json> as JSON - if it
84			is valid JSON, the command outputs nothing, otherwise it will print an
85			error message and exit with non-zero exit status.
86
87	root	1.1	<src.json json_xs >pretty.json
88
89			Prettify the JSON file F<src.json> to F<dst.json>.
90
91			json_xs -f storable-file <file
92
93			Read the serialised Storable file F<file> and print a human-readable JSON
94			version of it to STDOUT.
95
96			json_xs -f storable-file -t yaml <file
97
98			Same as above, but write YAML instead (not using JSON at all :)
99
100	root	1.5	lwp-request http://cpantesters.perl.org/show/JSON-XS.json \| json_xs
101
102			Fetch the cpan-testers result summary C<JSON::XS> and pretty-print it.
103
104	root	1.1	=head1 AUTHOR
105
106			Copyright (C) 2008 Marc Lehmann <json@schmorp.de>
107
108			=cut
109
110			use strict;
111
112			use Getopt::Long;
113	root	1.3	use Storable ();
114	root	1.1	use Encode;
115
116			use JSON::XS;
117
118			my $opt_verbose;
119			my $opt_from = "json";
120			my $opt_to = "json-pretty";
121
122			Getopt::Long::Configure ("bundling", "no_ignore_case", "require_order");
123
124			GetOptions(
125			"v" => \$opt_verbose,
126			"f=s" => \$opt_from,
127			"t=s" => \$opt_to,
128			) or die "Usage: $0 [-v] -f fromformat [-t toformat]\n";
129
130			my %F = (
131			"json" => sub {
132			my $enc =
133			/^\x00\x00\x00/s ? "utf-32be"
134			: /^\x00.\x00/s ? "utf-16be"
135			: /^.\x00\x00\x00/s ? "utf-32le"
136			: /^.\x00.\x00/s ? "utf-16le"
137			: "utf-8";
138			warn "input text encoding is $enc\n" if $opt_verbose;
139			JSON::XS->new->decode (decode $enc, $_)
140			},
141	root	1.3	"storable" => sub { Storable::thaw $_ },
142	root	1.1	"storable-file" => sub { open my $fh, "<", \$_; Storable::fd_retrieve $fh },
143			"clzf" => sub { require Compress::LZF; Compress::LZF::sthaw ($_) },
144			"yaml" => sub { require YAML; YAML::Load ($_) },
145			);
146
147			my %T = (
148			"null" => sub { "" },
149			"json" => sub { encode_json $_ },
150			"json-utf-8" => sub { encode_json $_ },
151			"json-pretty" => sub { JSON::XS->new->utf8->pretty->encode ($_) },
152			"json-utf-16le" => sub { encode "utf-16le", JSON::XS->new->encode ($_) },
153			"json-utf-16be" => sub { encode "utf-16be", JSON::XS->new->encode ($_) },
154			"json-utf-32le" => sub { encode "utf-32le", JSON::XS->new->encode ($_) },
155			"json-utf-32be" => sub { encode "utf-32be", JSON::XS->new->encode ($_) },
156
157			"storable" => sub { Storable::nfreeze $_ },
158			"storable-file" => sub { open my $fh, ">", \my $buf; Storable::nstore_fd $_, $fh; $buf },
159
160			"clzf" => sub { require Compress::LZF; Compress::LZF::sfreeze_cr ($_) },
161			"yaml" => sub { require YAML; YAML::Dump ($_) },
162	root	1.6	"dumper" => sub {
163			require Data::Dumper;
164			local $Data::Dumper::Terse = 1;
165			local $Data::Dumper::Indent = 1;
166			local $Data::Dumper::Useqq = 1;
167			local $Data::Dumper::Quotekeys = 0;
168			local $Data::Dumper::Sortkeys = 1;
169			Data::Dumper::Dumper($_)
170			},
171	root	1.7	"dump" => sub {
172			require Data::Dump;
173			local $Data::Dump::TRY_BASE64 = 0;
174			Data::Dump::dump ($_) . "\n"
175			},
176	root	1.1	);
177
178			$F{$opt_from}
179			or die "$opt_from: not a valid fromformat\n";
180
181			$T{$opt_to}
182			or die "$opt_from: not a valid toformat\n";
183
184			{
185			local $/;
186			binmode STDIN; # stupid perl sometimes thinks its funny
187			$_ = <STDIN>;
188			}
189
190			$_ = $F{$opt_from}->();
191			$_ = $T{$opt_to}->();
192
193			binmode STDOUT;
194			print $_;
195
196
197