CPAN::Groonga

detected. I hope META.json is already exists here\n");
            $metafile = 'META.json';
        } else {
            cmd_perl('Build.PL');
            $metafile = 'MYMETA.json';
        }
    } el

     cmd_perl('Makefile.PL');
        cmd($Config{make}, 'metafile');
        $metafile = 'MYMETA.json';
    } elsif (-f 'dist.ini') {
        my %orig = map { $_ => 1 } glob('*/META.yml');
        cm

T.SKIP.bak
        MANIFEST.bak
        README.pod
        META.yml
        README
        MYMETA.json
        MYMETA.yml
        inc/Module/Install.pm
    ), glob('inc/Module/Install/*.pm')) {
      

lf->main_module_path;
}

sub regenerate_files {
    my $self = shift;

    $self->regenerate_meta_json();
    $self->regenerate_readme_md();
    $self->module_maker->generate($self);
    if (Cwd::getc

lf);
    }
}

sub regenerate_meta_json {
    my $self = shift;

    my $meta = $self->cpan_meta('unstable');
    $meta->save(File::Spec->catfile($self->dir, 'META.json'), {
        version => '2.0'
  

ve::Zip->new();
    my $manifest =
      $zip->addString( $class->_manifest_contents(), 'manifest.json' );
    $manifest->desiredCompressionMethod( Archive::Zip::COMPRESSION_DEFLATED() );
    my $cont

(
            "Failed to close '$bcd_path':$EXTENDED_OS_ERROR");
        %browser_properties = %{ JSON->new()->decode($bcd_contents) };
    }
    elsif ( $OS_ERROR == POSIX::ENOENT() ) {
        Carp:

 return;
    }
    elsif ($la->[$i] ne $ra->[$i]) {
      return;
    }
  }
  return 1;
}

sub TO_JSON {
  (my MY $self) = @_;
  [$self->as_sql_bind];
}

sub SQL {
  MY->new(sep => ' ')->concat(@_);
}

b _build_manifest_files {
    my $self = shift;
    my @files = (@{$self->files}, qw(LICENSE META.json META.yml MANIFEST));
    if (-f File::Spec->catfile($self->dir, 'Makefile.PL')) {
        push @f

      $meta->save('META.yml', {
            version => 1.4,
        });
        $meta->save('META.json', {
            version => 2.0,
        });
    }

    {
        infof("Writing MANIFEST file\n")

package Net::Z3950::FOLIO;

use 5.008000;
use strict;
use warnings;

use Cpanel::JSON::XS qw(decode_json encode_json);
use Net::Z3950::SimpleServer;
use ZOOM; # For ZOOM::Exception
use LWP::UserAgent;

sub FORMAT_USMARC { '1.2.840.10003.5.10' }
sub FORMAT_XML { '1.2.840.10003.5.109.10' }
sub FORMAT_JSON { '1.2.840.10003.5.1000.81.3' }
sub ATTRSET_BIB1 { '1.2.840.10003.3.1' }


=head1 NAME

Net::Z395

g');

Creates and returns a new Net::Z3950::FOLIO object, configured according to
the JSON file C<$configFile.json> specified by the only argument.  The format of
this file is described in C<Net::Z395

:Entities qw/encode_entities/;
use POSIX          qw/strftime/;

our %exporters = (
	json   => 'OODoc::Export::JSON',
);

#--------------------

sub new(%)
{	my ($class, %args) = @_;

	$class eq __PAC

;
use JSON;
use List::Util qw(any none);
use Scalar::Util qw(blessed reftype refaddr looks_like_number);
use Term::ANSIColor;
use Time::Piece;
use Time::HiRes qw(time);
use Text::Diff;

use JSON;

use

  normalize_name
  normalize_time_range
  normalize_timestamp
  toCamelCase
  slurp_file
  write_json_file
  fetch_acm
  fetch_cloudtrail
  fetch_application_autoscaling
  fetch_ecr
  fetch_ec2
  fet

$old, $new, $options ) = @_;

  my $json = JSON->new->canonical->pretty->allow_blessed->convert_blessed;

  my $old_str = $json->encode($old);
  my $new_str = $json->encode($new);

  # normalize line 

package App::IAM;

use strict;
use warnings;

use Carp;
use Data::Dumper;
use JSON;
use English qw(-no_match_vars);
use File::Temp qw(tempfile);

use Role::Tiny::With;
with 'App::AWS';

use parent qw(

 = $self->get_policy_document;

  my ( $json_path, $fh ) = tempfile( 'policy-XXXXX', UNLINK => $self->get_unlink, SUFFIX => '.json' );

  print {$fh} encode_json($doc);

  close $fh;

  my @cmd = (
  

s', 'iam', 'create-policy',
    '--policy-name'     => $name,
    '--policy-document' => "file://$json_path",
    '--profile'         => $self->profile,
  );

  return $self->execute(@cmd);
}

#######

package App::ACM;

use strict;
use warnings;

use Role::Tiny::With;
use JSON;
use File::Temp qw(tempfile);
use Data::Dumper;

with 'App::AWS';

use parent 'App::Command';

__PACKAGE__->follow_best_pra

bucket_name;

  if ( $policy =~ /[.]json$/xms && -s $policy ) {
    $policy = '--cli-input-json ' . $policy;
  }
  elsif ( $policy =~ /\s*{/xsm && eval { decode_json($policy) } ) {
    $policy = '--po

Route53;

use strict;
use warnings;

use Carp;
use File::Temp qw(tempfile);
use Data::Dumper;
use JSON;
use App::FargateStack::Constants;

use Role::Tiny::With;
with 'App::AWS';

use parent 'App::Comm

ne_id,
              DNSName              => $alb_dns_name,
              EvaluateTargetHealth => JSON::false,
            }
          }
        }
      ]
    }
  };

  return $self->change_resource_r

 '.json'
  );

  print {$fh} encode_json($change_batch);

  close $fh;

  return $self->command(
    'change-resource-record-sets' => [
      '--hosted-zone-id' => $zone_id,
      '--cli-input-json' =

h qw(-no_match_vars);
use File::Temp qw(tempfile);
use CLI::Simple::Constants qw(:booleans);

use JSON;
use Scalar::Util qw(reftype);

use Role::Tiny::With;
with 'App::AWS';

use parent qw(App::Comman

_token,
      $description ? ( '--description' => $description ) : (),
      '--cli-input-json' => encode_json( { RegularExpressionList => $regex_list } ),
      $query ? ( '--query' => $query ) : (),

$filename ) = tempfile( 'rulesXXXX', UNLINK => $ENV{NO_UNLINK} ? $FALSE : $TRUE );

  print {$fh} JSON->new->pretty->encode($rules);

  close $fh;

  return $filename;
}

#############################

teStack::Builder::Utils qw(choose);

use Carp;
use Data::Dumper;
use File::Temp qw(tempfile);
use JSON;
use Scalar::Util qw(reftype);
use List::Util qw(pairs);

use parent qw(App::Command);

use Role:

  my $result
    = $self->command( 'register-task-definition' => [ '--no-cli-pager', '--cli-input-json' => "file://$task_definition", ] );

  return $result;
}

#######################################

work_configuration subnets security_groups)) {
    next if !ref $args{$_};
    $args{$_} = encode_json( $args{$_} );
  }

  return $self->command(
    'run-task' => [
      '--cluster'               =

gs;

  my $options = $self->fetch_option_defaults;

  my $defaults_file = '.fargatestack/defaults.json';

  if ($config_name) {
    my ( $name, $path, $ext ) = fileparse( $config_name, qr/[.][^.]+$/xs

ile not found: [%s]\n", $fqp
      if !-s $fqp;

    $options->{config} = $fqp;

    $self->write_json_file( $defaults_file, $options );
    $config_name = $name;
  }

  my $data = [
    { Profile    

action, $ENV{SCRIPT_NAME} )
    if !$task_name;

  my $task_definition_file = sprintf 'taskdef-%s.json', $task_name;

  $self->check_task($task_name);

  log_die( $self, "ERROR: no task definition fil

3950::FOLIO::Config;

use 5.008000;
use strict;
use warnings;

use IO::File;
use Cpanel::JSON::XS qw(decode_json);


# Possible values of $missingAction
sub MISSING_ERROR { 0 }
sub MISSING_TENANT { 1 

ase, $cfgsub, $missingAction) = @_;

    my $cfgname = $cfgbase . ($cfgsub ? ".$cfgsub" : '') . '.json';
    my $fh = new IO::File("<$cfgname");
    if (!$fh) {
	if ($! == 2 && $missingAction == MISSI

}
	die "$0: can't open config file '$cfgbase.json': $!"
    }

    my $json; { local $/; $json = <$fh> };
    $fh->close();

    my $cfg = decode_json($json);
    _expandVariableReferences($cfg);
    

me qw(basename fileparse dirname);
use File::Temp qw(tempfile tempdir);
use IPC::Run qw(run);
use JSON;
use Readonly;

use Role::Tiny::With;

with 'App::Logger';
with 'App::BenchmarkRole';

Readonly::

package Mojolicious::Plugin::Inertia;
use Mojo::Base 'Mojolicious::Plugin';
use Mojo::JSON qw(encode_json);
use Scalar::Util qw(reftype);
use Carp qw(croak);

our $VERSION = "0.01";

sub register {
  

tory,
        };

        # Check if the request is an Inertia request.
        # If so, return a JSON response.
        # Else, return an HTML response with embedded page object.
        # Ref: https

rue');
            $c->res->headers->header('Vary' => 'X-Inertia');
            return $c->render(json => $page_object);
        }
        else {
            $c->res->headers->header('Vary' => 'X-Iner

nts;
use Carp;
use Data::Dumper;
use English qw(-no_match_vars);
use File::Temp qw(tempfile);
use JSON;
use List::Util qw(none any);
use Scalar::Util qw(reftype);

use Role::Tiny::With;
with 'App::AWS

le-XXXXX',
    UNLINK => $self->get_unlink,
    SUFFIX => '.json'
  );

  my $json = JSON->new->pretty->encode($target);

  print {$fh} $json;

  close $fh;

  return $self->command(
    'put-targets'

ve::Zip->new();
    my $manifest =
      $zip->addString( $class->_manifest_contents(), 'manifest.json' );
    $manifest->desiredCompressionMethod( Archive::Zip::COMPRESSION_DEFLATED() );
    my $cont