File Coverage

blib/lib/JMAP/Tester/Response/Paragraph.pm

Criterion	Covered	Total	%
statement	83	83	100.0
branch	20	20	100.0
condition	3	3	100.0
subroutine	16	16	100.0
pod	8	11	72.7
total	130	133	97.7

use v5.20.0;
package JMAP::Tester::Response::Paragraph 0.110;
# ABSTRACT: a group of sentences in a JMAP response

use Moo;
use experimental 'signatures';

use JMAP::Tester::Abort 'abort';

use namespace::clean;

#pod =head1 OVERVIEW
#pod
#pod These objects represent paragraphs in the JMAP response.  That is, if your
#pod response is:
#pod
#pod   [
#pod     [ "messages", { ... }, "a" ],      # 1
#pod     [ "smellUpdates", { ... }, "b" ],  # 2
#pod     [ "smells",       { ... }, "b" ],  # 3
#pod   ]
#pod
#pod ...then #1 forms one paragraph and #2 and #3 together form another.  It goes by
#pod matching client ids.
#pod
#pod =cut

sub client_id ($self) {
  $self->_sentences->[0]->client_id;
}

sub BUILD {
  abort("tried to build 0-sentence paragraph")
    unless @{ $_[0]->_sentences };

  my $client_id = $_[0]->_sentences->[0]->client_id;
  abort("tried to build paragraph with non-uniform client_ids")
    if grep {; $_->client_id ne $client_id } @{ $_[0]->_sentences };
}

has sentences => (is => 'bare', reader => '_sentences', required => 1);

#pod =method sentences
#pod
#pod The C method returns a list of
#pod L objects, one for each sentence
#pod in the paragraph.
#pod
#pod =cut

sub sentences ($self) { @{ $self->_sentences } }

#pod =method sentence
#pod
#pod   my $sentence = $para->sentence($n);
#pod
#pod This method returns the Ith sentence of the paragraph.
#pod
#pod =cut

sub sentence ($self, $n) {
  abort("there is no sentence for index $n")
    unless $self->_sentences->[$n];
}

#pod =method single
#pod
#pod   my $sentence = $para->single;
#pod   my $sentence = $para->single($name);
#pod
#pod This method throws an exception if there is more than one sentence in the
#pod paragraph.  If a C<$name> argument is given and the paragraph's single
#pod sentence doesn't have that name, an exception is raised.
#pod
#pod Otherwise, this method returns the sentence.
#pod
#pod =cut

sub single ($self, $name = undef) {
  my @sentences = $self->sentences;

  abort("more than one sentence in paragraph, but ->single called")
    if @sentences > 1;

  abort("single sentence not of expected name <$name>")
    if defined $name && $name ne $sentences[0]->name;

  return $sentences[0];
}

#pod =method assert_n_sentences
#pod
#pod   my ($s1, $s2, ...) = $paragraph->assert_n_sentences($n);
#pod
#pod This method returns all the sentences in the paragarph, as long as there are
#pod exactly C<$n>.  Otherwise, it aborts.
#pod
#pod =cut

sub assert_n_sentences ($self, $n) {
  Carp::confess("no sentence count given") unless defined $n;

  my @sentences = $self->sentences;

  unless (@sentences == $n) {
    abort("expected $n sentences but got " . @sentences)
  }

  return @sentences;
}

#pod =method sentence_named
#pod
#pod   my $sentence = $paragraph->sentence_named($name);
#pod
#pod This method returns the sentence with the given name.  If no such sentence
#pod exists, or if two sentences with the name exist, the tester will abort.
#pod
#pod =cut

sub sentence_named ($self, $name) {
  Carp::confess("no sentence name given") unless defined $name;

  my @sentences = grep {; $_->name eq $name } $self->sentences;

  unless (@sentences) {
    abort(qq{no sentence found with name "$name"});
  }

  if (@sentences > 1) {
    abort(qq{found more than one sentence with name "$name"});
  }

  return $sentences[0];
}

#pod =method as_triples
#pod
#pod =method as_stripped_triples
#pod
#pod C returns an arrayref containing the result of calling
#pod C on each sentence in the paragraph. C removes
#pod JSON types.
#pod
#pod =cut

sub as_triples ($self) {
  [ map {; $_->as_triple } $self->sentences ]
}

sub as_stripped_triples ($self) {
  [ map {; $_->as_stripped_triple } $self->sentences ]
}

#pod =method as_pairs
#pod
#pod C returns an arrayref containing the result of calling C
#pod on each sentence in the paragraph. C removes JSON types.
#pod
#pod =cut

sub as_pairs ($self) {
  [ map {; $_->as_pair } $self->sentences ]
}

sub as_stripped_pairs ($self) {
  [ map {; $_->as_stripped_pair } $self->sentences ]
}

1;

__END__