CPAN::Groonga

package Sledge::Plugin::JSON;
use warnings;
use strict;

use JSON::Syck;

our $VERSION = '0.01';
our $ConformToRFC4627 = 0;

sub import {
    my $self = shift;
    my $pkg  = caller;

    no strict 'r

efs';
    *{"$pkg\::output_json"} = \&_output_json;
}

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

    my $encoding = $args->{encoding} ? $args->{encoding} : 'utf-8';

    my $content_type =
     

self, $encoding );

    my $json = JSON::Syck::Dump($args->{data});
    my $output = _add_callback($self, _validate_callback_param($self, $self->r->param('callback')), $json );

    $self->r->content_

package Plagger::Plugin::Publish::JSON;
use strict;
use base qw( Plagger::Plugin );

use File::Spec;
use JSON::Syck;
use Plagger::Walker;
use Plagger::Util;

sub init {
    my $self = shift;
    $self

| '%i.json');
    my $path = File::Spec->catfile($self->conf->{dir}, $file);
    $context->log(info => "writing output to $path");

    local $JSON::Syck::ImplicitUnicode = 1;
    my $body = JSON::Syc

conf->{varname}) {
        $body = "var $var = $body;";
    } elsif (my $jsonp = $self->conf->{jsonp}) {
        $body = "$jsonp($body)";
    }

    $context->log(info => "Serializing " . $args->{feed

package EVDB::API::JSON;

use strict;
use warnings;
use Carp;

=head1 NAME

EVDB::API::JSON - Use the JSON flavor of the Eventful API

=head1 SYNOPSIS

    my $evdb    = EVDB::API->new(app_key => $app

-001336058-5' });

=head1 DESCRIPTION

Parses JSON from the Eventful API.

=head1 METHODS

=head2 flavor

Return the flavor name.

=cut

sub flavor { 'json' }

=head2 ctype

Return a checkstring for t

 content type.

=cut

sub ctype { 'javascript' }

=head2 parse

Parse JSON data from the Eventful API using L<JSON::Syck> or L<JSON>.

=cut

sub parse {
    my ($class, $data, $force_array) = @_;

   

ckage Kwiki::JSON;

use warnings;
use strict;
use Kwiki::Plugin '-Base';
use mixin 'Kwiki::Installer';
our $VERSION = '0.01';

const class_title => 'JSON Library';
const class_id => 'json';
const java

> 'json.js';

sub register {
        my $registry = shift;
        $registry->add(preload => 'json', priority => 1);
}

1; # End of Kwiki::JSON

__DATA__
=head1 NAME

Kwiki::JSON - Provides the JSON j

S

The developers of the JSON language as well as the many implementations of
JSON. It is great to have data structures than can be understood by all
languages and without JSON many of my project woul

package Data::Phrasebook::Loader::JSON::Syck;

use strict;
use warnings;

use Carp        'croak';
use JSON::Syck  ();
use File::Slurp ();

use Data::Phrasebook;

our $VERSION = '0.01';

use base 'Da

 not be found";        
    my $json = File::Slurp::slurp($filename) or croak "Could not slurp JSON file '$filename' got no data";
    my $d    = JSON::Syck::Load($json);
    (ref($d) eq 'HASH')
     

JSON file '$filename'";
	$class->{JSON} = $d;    
}

sub get { 
	my ($class, $key) = @_;
	return undef unless $key;
	return undef unless $class->{JSON};
	$class->{JSON}->{$key};    
}

#sub dicts    {

ackage JSON::Syck;
use strict;

use Exporter;
use DynaLoader;

our $VERSION = '0.07';
our @EXPORT_OK  = qw( Dump Load );
our @ISA     = qw( Exporter DynaLoader );

__PACKAGE__->bootstrap;

$JSON::Syck

g  = 1;
$JSON::Syck::Headless        = 1;
$JSON::Syck::ImplicitUnicode = 0;
$JSON::Syck::SingleQuote     = 0;

1;

__END__

=head1 NAME

JSON::Syck - JSON is YAML

=head1 SYNOPSIS

  use JSON::Syck;

  my $data = JSON::Syck::Load($json);
  my $json = JSON::Syck::Dump($data);

=head1 DESCRIPTION

JSON::Syck is a syck implementatoin of JSON parsing and
generation. Because JSON is YAML
(L<http://redh

Plugin::Config::JSON;

use strict;
use warnings;

use UNIVERSAL 'isa';

use NEXT;
use JSON;
use Path::Class 'file';

our $VERSION = '0.03';

=head1 NAME

Catalyst::Plugin::Config::JSON - Configure you

r Catalyst application via an external
JSON file

=head1 SYNOPSIS

    use Catalyst 'Config::JSON';
    
    __PACKAGE__->config('config_file' => 'config.json');

=head1 DESCRIPTION

This Catalyst plu

gin enables you to configure your Catalyst application with an 
external JSON file instead of somewhere in your application code.

This is useful for example if you want to quickly change the configur

package SPVM::Builder::Info;

use strict;
use warnings;
use Carp 'confess';
use JSON::PP;
use File::Basename 'basename';

use SPVM::Builder;
use SPVM::Builder::CC;
use SPVM::Builder::Util;
use SPVM::B

quired_resources;
}

sub get_required_resource_json_lines {
  my ($self) = @_;
  
  my $required_resources = $self->get_required_resources;
  
  my @json_lines;
  for my $required_resource (@$required

} = $resource_argv;
    }
    
    my $json_line = JSON::PP->new->utf8->canonical(1)->encode($line);
    
    push @json_lines, $json_line;
  }
  
  return \@json_lines;
}

sub compile {
  my ($self) 

package SPVM::Builder::Config::Info;

use strict;
use warnings;
use Carp 'confess';
use JSON::PP;
use File::Basename 'basename';

use SPVM::Builder;
use SPVM::Builder::CC;
use SPVM::Builder::Util;

# 

package SPVM::Builder::ScriptInfo;

use strict;
use warnings;
use Carp 'confess';
use JSON::PP;
use File::Basename 'basename';

use SPVM::Builder;
use SPVM::Builder::CC;
use SPVM::Builder::Util;
use S

tem * L<SPVM::HTTP::Tiny>

=item * L<SPVM::IO>

=item * L<SPVM::IO::Socket::SSL>

=item * L<SPVM::JSON>

=item * L<SPVM::Math>

=item * L<SPVM::MIME::Base64>

=item * L<SPVM::Mojolicious>

=item * L<S

package SPVM::Builder::Exe;

use strict;
use warnings;
use Carp ();
use JSON::PP;
use File::Basename 'basename', 'dirname', 'fileparse';
use File::Path 'mkpath', 'rmtree';
use File::Find 'find';
use A

lf) = @_;
  
  my $gitignore_content = <<'EOS';
/blib
/Makefile
/Makefile.old
/MYMETA.yml
/MYMETA.json
/pm_to_blib
/core.*
/core
/SPVM-*
*.bak
*.BAK
*.tmp
*.o
*.bs
.tmp
.git
.spvm_build
EOS
  
  # Gen

  my $manifest_skip_content = <<'EOS';
^blib(/|$)
^Makefile$
^Makefile.old$
^MYMETA.yml$
^MYMETA.json$
^pm_to_blib$
^core\.
^core$
^SPVM-
\.bak$
\.BAK$
\.tmp$
\.o$
\.bs$
(^|/)\.tmp(/|$)
(^|/)\.git(/|

package SPVM::Builder::DependencyAnalyzer;

use strict;
use warnings;
use Carp 'confess';
use JSON::PP ();
use File::Basename 'basename';

use SPVM::Builder;
use SPVM::Builder::CC;
use SPVM::Builder::

ion_from;
    }
    
    push @$class_infos, $class_info;
  }
  
  return $class_infos;
}

sub to_json {
  my ($self) = @_;
  
  my $script_name = $self->{script_name};
  
  my $with_version = $self->

 $script_name);
  
  my $class_infos = $self->to_class_infos;
  
  my $class_names = [];
  
  my $json = "[\x0A";
  
  for (my $i = 0; $i < @$class_infos; $i++) {
    my $class_info = $class_infos->[$

 for the hash
          my $mitme_and_size_json = qq|{mtime":$stat_result[9],"size":$stat_result[7]}|;
          $dependent_file_sha->add($mitme_and_size_json);
        }
      }
      $dependant_file

t data, multiple in/out formats, IP security, role based access
# Multiple input/output formats : json , xml , yaml, perl , human
#
# George Bouras , george.mpouras@yandex.com
# Joan Ntzougani, ✞

p

anel::JSON::XS; my $JSON = Cpanel::JSON::XS->new; $JSON->utf8(1); $JSON->indent(0); $JSON->canonical(0); $JSON->pretty(0); $JSON->max_size(0); $JSON->space_before(0); $JSON->space_after(1); $JSON->rel

axed(0); $JSON->allow_tags(1); $JSON->allow_unknown(0); $JSON->shrink(0); $JSON->allow_nonref(0); $JSON->allow_blessed(0); $JSON->convert_blessed(0); $JSON->max_depth(1024);
use YAML::XS;         my $

ter;
our @ISA = qw(Exporter);
our @EXPORT = qw($select_clipbucket_setup);

use File::HomeDir;
use JSON::XS;
use POSIX qw(strftime);
my $home_dir=File::HomeDir->my_home.'/';

use Net::FullAuto::Cloud::

e->cmd(
      'sudo yum -y install php55 php55-curl php55-gd php55-gmp '.
      'php55-intl php55-json php55-opcache php55-mysqlnd '.
      'php55-mbstring php55-devel php55-fpm php55-cli openssl-deve

ub.com/users/gpac/repos';
   ($stdout,$stderr)=$local->cmd($c);
   my @repos=();
   @repos=decode_json($stdout);
   my $default_branch=$repos[0]->[1]->{'default_branch'};
   my $updated=$repos[0]->[1]

e_demo_setup}<';

};

my $openldap_setup_summary=sub {

   package openldap_setup_summary;
   use JSON::XS;
   my $region="]T[{awsregions}";
   $region=~s/^"//;
   $region=~s/"$//;
   my $type="]T[{se

$lrhandle->{_cmd_handle}->print("\003");
         last;
      }
      sleep 1;
   }
   my ($hash,$json,$output,$error)=('','','','');
   my $in_id=$lr_inst->{InstanceId};
   ($hash,$output,$error)=
  

lAuto::FA_Core::cleanup;

};

my $chef_setup_summary=sub {

   package chef_setup_summary;
   use JSON::XS;
   my $region="]T[{awsregions}";
   $region=~s/^"//;
   $region=~s/"$//;
   my $type="]T[{se

X::StrictConstructor 
      MooseX::NonMoose
      Business::ISBN
      App::FatPacker
      JSON
      JSON::XS
      Test::DistManifest
      Term::Size::Any
      Type::Tiny
      File::ReadBackwar

####

   INSTALLING Catalyst::View::JSON

########################################
END
   print $show;
   sleep 1;
   cmd_raw($handle,'sudo cpan Catalyst::View::JSON','__display__');
   $show=<<END;
 

e_demo_setup}<';

};

my $catalyst_setup_summary=sub {

   package catalyst_setup_summary;
   use JSON::XS;
   my $region="]T[{awsregions}";
   $region=~s/^"//;
   $region=~s/"$//;
   my $type="]T[{se