CPAN::Groonga

>new });


sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{encr}  = $self->encr  if @{$self->encr};
    $json->{prf}   = $self->prf   if @{$self->prf};
    $json->{integ} = $self

f->integ};
    $json->{ke}    = $self->ke    if @{$self->ke};
    $json->{esn}   = $self->esn   if @{$self->esn};
    $json->{auth}  = $self->auth  if @{$self->auth};

    return $json;

}

1;

=encod

 isa => Num);

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{primitive}                = $self->primitive                   if $self->primitive;
    $json->{parameterSetIdentif

ntifier    if $self->parameter_set_identifier;
    $json->{curve}                    = $self->curve                       if $self->curve;
    $json->{executionEnvironment}     = $self->execution_envi

     if $self->execution_environment;
    $json->{implementationPlatform}   = $self->implementation_platform     if $self->implementation_platform;
    $json->{certificationLevel}       = $self->certi

loneDX::List->new });

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{type}                = $self->type                  if $self->type;
    $json->{version}             = $sel

   $json->{cipherSuites}        = $self->cipher_suites         if @{$self->cipher_suites};
    $json->{ikev2TransformTypes} = $self->ikev2_transform_types if $self->ikev2_transform_types;
    $json->{

cryptoRefArray}      = $self->crypto_ref_array      if @{$self->crypto_ref_array};

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::CryptoProperties::ProtocolProperties - Prot

O_JSON {

    my $self = shift;

    my $json = {};

    $json->{type}           = $self->type            if $self->type;
    $json->{id}             = $self->id              if $self->id;
    $json->

 $self->state;
    $json->{algorithmRef}   = $self->algorithm_ref   if $self->algorithm_ref;
    $json->{creationDate}   = $self->creation_date   if $self->creation_date;
    $json->{activationDate} =

tivation_date;
    $json->{updateDate}     = $self->update_date     if $self->update_date;
    $json->{expirationDate} = $self->expiration_date if $self->expiration_date;
    $json->{value}          =

 TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{name}        = $self->name        if $self->name;
    $json->{algorithms}  = $self->algorithms  if @{$self->algorithms};
    $json->{

identifiers} = $self->identifiers if @{$self->identifiers};

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::CryptoProperties::CipherSuite - Object representing
a cipher suite

a => Str);

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{name} = $self->name if $self->name;
    $json->{url}  = $self->url  if $self->url;

    return $json;

}

1;

=encodin

:CycloneDX::List->new });


sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{mechanism}    = $self->mechanism     if $self->mechanism;
    $json->{algorithmRef} = $self->algorithm

_ref if @{$self->algorithm_ref};

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::CryptoProperties::SecuredBy - The mechanism by which the cryptographic asset is secured by

=

', isa => Str);

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{subjectName}           = $self->subject_name            if $self->subject_name;
    $json->{issuerName}          

  $json->{notValidBefore}        = $self->not_valid_before        if $self->not_valid_before;
    $json->{notValidAfter}         = $self->not_valid_after         if $self->not_valid_after;
    $json->

hm_ref if $self->signature_algorithm_ref;
    $json->{subjectPublicKeyRef}   = $self->subject_public_key_ref  if $self->subject_public_key_ref;
    $json->{certificateFormat}     = $self->certificate_

M::CycloneDX::Service']);

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{organization} = $self->organization if $self->organization;
    $json->{individual}   = $self->individu

nt}    = $self->component    if $self->component;
    $json->{service}      = $self->service      if $self->service;

    my @check = keys %{$json};

    if (scalar @check != 1) {
        Carp::croak 

on", "individual", "component" and "service" cannot be used at the same time';
    }

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::Annotation::Annotator - Annotator

=head1

a => Str);

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{name} = $self->name if $self->name;
    $json->{url}  = $self->url  if $self->url;

    return $json;

}

1;

=encodin

lnerability::Source'], required => 1);

sub TO_JSON {

    my $self = shift;

    my $json = {id => $self->id, source => $self->source};

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::

TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{source}        = $self->source        if $self->source;
    $json->{score}         = $self->score         if $self->score;
    $json->

     if $self->severity;
    $json->{method}        = $self->method        if $self->method;
    $json->{vector}        = $self->vector        if $self->vector;
    $json->{justification} = $self->jus

tification if $self->justification;

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::Vulnerability::Rating - Rating

=head1 SYNOPSIS

    SBOM::CycloneDX::Vulnerability::Ratin

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{phase}       = $self->phase       if $self->phase;
    $json->{name}        = $self->name        if $self->name;
    $json->{desc

ription} = $self->description if $self->description;

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::Metadata::Lifecycle - Lifecycle

=head1 SYNOPSIS

    SBOM::CycloneDX::Me

oneDX::List->new }
);

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{'bom-ref'}          = $self->bom_ref             if $self->bom_ref;
    $json->{identifier}         = $self

lf->identifier;
    $json->{title}              = $self->title               if $self->title;
    $json->{text}               = $self->text                if $self->text;
    $json->{descriptions}    

escriptions;
    $json->{openCre}            = $self->open_cre            if $self->open_cre;
    $json->{parent}             = $self->parent              if $self->parent;
    $json->{properties}    

O_JSON {

    my $self = shift;

    my $json = {};

    $json->{'bom-ref'}    = $self->bom_ref      if $self->bom_ref;
    $json->{identifier}   = $self->identifier   if $self->identifier;
    $json-

f $self->title;
    $json->{description}  = $self->description  if $self->description;
    $json->{requirements} = $self->requirements if @{$self->requirements};

    return $json;

}

1;

=encoding u

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

use strict;
use warnings;
use parent qw( HiPi::Class );
use File::Path ( );

use JSON;
use Try::Tiny;
use Storable;
use Carp;

__PACKAGE__->create_ro_accessors( qw( configclass filepa

!) );
    read( $fh, my $input, -s $fh);
    close( $fh );
    my $json = JSON->new;
    my $conf = try {
        my $decoded = $json->decode( $input );
        return $decoded;
    } catch {
        

lepath ) or croak( qq(failed to open config file : $!) );
    my $json = JSON->new;
    my $output = try {
        my $encoded = $json->pretty->canonical->encode( $self->config );
        return $enco

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{summary}   = $self->summary   if $self->summary;
    $json->{assessor}  = $self->assessor  if $self->assessor;
    $json->{map} 

      = $self->map       if @{$self->map};
    $json->{signature} = $self->signature if $self->signature;

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::Declarations::Attest

ttestors
declared conformance and confidence thereof.

=item C<signature>, Enveloped signature in JSON Signature Format (JSF)
(L<https://cyberphone.github.io/doc/security/jsf.html>).

=item C<summary>

::Browseable::Store::File;
use Apache::Session::Generate::SHA256;
use Apache::Session::Serialize::JSON;
use Apache::Session::Browseable::_common;

use constant SL => ( $^O and $^O =~ /(?:MSWin|Windows

e;
    $self->{serialize}    = \&Apache::Session::Serialize::JSON::serialize;
    $self->{unserialize}  = \&Apache::Session::Serialize::JSON::unserialize;

    return $self;
}

sub DESTROY {
    my $s

) eq 'CODE' ) {
                $res{$f} =
                  &$data( &Apache::Session::Serialize::JSON::_unserialize($row),
                    $f );
            }
            elsif ($data) {
        

Plugin::MetaNoIndex;
use Dist::Zilla::Plugin::MetaProvides::Package;
use Dist::Zilla::Plugin::MetaJSON;
use Dist::Zilla::Plugin::ModuleBuild;
use Dist::Zilla::Plugin::Manifest;
use Dist::Zilla::Plugin

>add_plugins(
        [ 'Git::GatherDir' =>
            { exclude_filename => [qw/README.pod META.json cpanfile LICENSE/] }],
        'PruneCruft',
        'ManifestSkip',
        'License',
        [

examples/],
        }],
        ['MetaProvides::Package' => { meta_noindex => 1 } ],
        'MetaJSON',
        'ModuleBuild',
        'Manifest',
        ['AutoPrereqs' => {skips=>['^strict$','^warn

e Archive::Tar;
use CPAN::cpanminus::reporter::RetainReports;
use Data::Dump ( qw| dd pp | );
use JSON;
use Path::Tiny;
use Text::CSV_XS;

=head1 NAME

Test::Against::Build - Test CPAN modules against

alysis_dir = $self->analyze_cpanm_build_logs( { verbose => 1 } );

    $fcdvfile = $self->analyze_json_logs( { verbose => 1, sep_char => '|' } );

=head1 DESCRIPTION

=head2 Who Should Use This Librar

with methods to run F<cpanm> against a specific list of modules, parse the
results into files in JSON format and then summarize those results in a
delimiter-separated-values file (such as a pipe-sepa