"v" .');
is_deeply([sort $map->list_prefixes], [qw(eg rdf)]);
my $rdf = $map->namespace_uri('rdf');
isa_ok($rdf, 'URI::Namespace');
is($rdf->as_string, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#');
};
subtest 'bnode prefix' => sub {
my $parser = Attean->get_parser('RDFXML')->new( bnode_prefix => 'foo' );
my ($t) = $parser->parse_list_from_bytes(<<"END");
Hello!
END
my $subj = $t->subject;
does_ok($subj, 'Attean::API::Blank');
like($subj->value, qr/^foo/, 'bnode prefix');
};
done_testing();
Attean-0.012/t/parser-sparql.t 000644 000765 000024 00000007600 12654563303 016255 0 ustar 00greg staff 000000 000000 use v5.14;
use autodie;
use utf8;
use Test::Modern;
use Test::Exception;
use FindBin qw($Bin);
use File::Glob qw(bsd_glob);
use File::Spec;
use Attean;
use Attean::RDF;
use AtteanX::SPARQL::Constants;
use Type::Tiny::Role;
subtest 'parser construction and metadata' => sub {
{
my $parser = Attean->get_parser('SPARQL')->new();
isa_ok( $parser, 'AtteanX::Parser::SPARQL' );
is($parser->canonical_media_type, 'application/sparql-query', 'canonical_media_type');
my %extensions = map { $_ => 1 } @{ $parser->file_extensions };
ok(exists $extensions{'rq'}, 'file_extensions');
}
{
my $parser = Attean->get_parser('SPARQLLex')->new();
isa_ok( $parser, 'AtteanX::Parser::SPARQLLex' );
is($parser->canonical_media_type, 'application/x-sparql-query-tokens', 'canonical_media_type');
my %extensions = map { $_ => 1 } @{ $parser->file_extensions };
ok(exists $extensions{'rq'}, 'file_extensions');
}
};
{
my $parser = Attean->get_parser('SPARQL')->new();
isa_ok($parser, 'AtteanX::Parser::SPARQL');
my $type = $parser->handled_type;
can_ok($type, 'role');
is($type->role, 'Attean::API::Algebra');
}
{
my $parser = Attean->get_parser('SPARQL')->new();
my $a = $parser->parse("SELECT * { ?s '''hello!''' OPTIONAL { ?s ?x } FILTER(!BOUND(?x)) } LIMIT 5 OFFSET 5");
does_ok($a, 'Attean::API::Algebra');
isa_ok($a, 'Attean::Algebra::Slice');
}
{
my $data = "ASK { ?s ?p ?o FILTER(?o > -2.0 && ?o < +3e0 ) }";
open(my $fh, '<', \$data);
my $parser = Attean->get_parser('SPARQL')->new();
my $iter = $parser->parse_iter_from_io($fh);
does_ok($iter, 'Attean::API::Iterator');
my $a = $iter->next;
does_ok($a, 'Attean::API::Algebra');
isa_ok($a, 'Attean::Algebra::Ask');
}
{
my $map = URI::NamespaceMap->new();
my $parser = Attean->get_parser('SPARQL')->new( namespaces => $map );
my $content = <<'END';
PREFIX ex:
PREFIX foaf:
SELECT * WHERE {
?s a foaf:Person ; foaf:name 'Alice'
}
OFFSET 10
END
my ($a) = $parser->parse_list_from_bytes($content);
is_deeply([sort $map->list_prefixes], [qw(ex foaf)]);
my $foaf = $map->namespace_uri('foaf');
isa_ok($foaf, 'URI::Namespace');
is($foaf->as_string, 'http://xmlns.com/foaf/0.1/');
isa_ok($a, 'Attean::Algebra::Slice')
}
subtest 'escaping' => sub {
my $sparql = q[ASK { ex:p "\\"", '\\'', '\\u706b\\U0000661F' \\u007d];
open(my $fh, '<:encoding(UTF-8)', \$sparql);
my $l = AtteanX::Parser::SPARQLLex->new();
my $iter = $l->parse_iter_from_io($fh);
expect($iter->next, KEYWORD, ['ASK']);
expect($iter->next, LBRACE, ['{'],);
expect($iter->next, IRI, ['s'], 'subject');
expect($iter->next, PREFIXNAME, ['ex:', 'p'], 'predicate');
expect($iter->next, STRING1D, ['"'], 'double quote');
expect($iter->next, COMMA, [',']);
expect($iter->next, STRING1S, ["'"], 'single quote');
expect($iter->next, COMMA, [',']);
expect($iter->next, STRING1S, ["火星"], 'unicode \\u and \\U escapes');
expect($iter->next, RBRACE, ['}'], 'escaped closing brace');
};
subtest 'custom function' => sub {
my $sparql = q[PREFIX ex: SELECT * WHERE { ?s ?p ?o FILTER(ex:test(?o)) }];
open(my $fh, '<:encoding(UTF-8)', \$sparql);
my $parser = AtteanX::Parser::SPARQL->new();
my ($a) = $parser->parse($sparql);
my ($f) = $a->subpatterns_of_type('Attean::Algebra::Filter');
isa_ok($f, 'Attean::Algebra::Filter');
my $expr = $f->expression;
isa_ok($expr, 'Attean::FunctionExpression');
is($expr->operator, 'INVOKE');
my ($iri, $term) = map { $_->value } @{ $expr->children };
does_ok($iri, 'Attean::API::IRI');
is($iri->value, 'http://example.org/test');
does_ok($term, 'Attean::API::Variable');
is($term->value, 'o');
};
done_testing();
sub expect {
my $token = shift;
my $type = shift;
my $values = shift;
my $name = shift // '';
if (length($name)) {
$name = "${name}: ";
}
is($token->type, $type, "${name}token type");
is_deeply($token->args, $values, "${name}token values");
}
Attean-0.012/t/parser-sparqljson.t 000644 000765 000024 00000005315 12651717125 017150 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
use autodie;
use Test::Modern;
use utf8;
use Attean;
sub iri { Attean::IRI->new(shift) }
sub blank { Attean::Blank->new(shift) }
sub literal {
my ($value, $lang, $dt) = @_;
if ($lang) {
return Attean::Literal->new(value => $value, language => $lang);
} elsif ($dt) {
return Attean::Literal->new(value => $value, datatype => $dt);
} else {
return Attean::Literal->new($value);
}
}
subtest 'parser construction and metadata' => sub {
my $parser = Attean->get_parser('SPARQLJSON')->new();
isa_ok($parser, 'AtteanX::Parser::SPARQLJSON');
is($parser->canonical_media_type, 'application/sparql-results+json', 'canonical_media_type');
my %extensions = map { $_ => 1 } @{ $parser->file_extensions };
ok(exists $extensions{'srj'}, 'file_extensions');
my $type = $parser->handled_type;
can_ok($type, 'role');
is($type->role, 'Attean::API::ResultOrTerm');
};
{
my $json = <<'END';
{
"head": { "vars": [ "x", "hpage", "name", "age", "mbox", "friend" ]
} ,
"results": {
"bindings": [
{
"x": { "type": "bnode" , "value": "r2" } ,
"hpage": { "type": "uri" , "value": "http://work.example.org/bob/" } ,
"name": { "type": "literal" , "value": "Bob", "xml:lang": "en" } ,
"age": { "type": "literal" , "value": "30", "datatype": "http://www.w3.org/2001/XMLSchema#integer" } ,
"mbox": { "type": "uri" , "value": "mailto:bob@work.example.org" }
}
]
}
}
END
my $counter = 0;
my $parser = Attean->get_parser('SPARQLJSON')->new(handler => sub {
$counter++;
my $result = shift;
does_ok($result, 'Attean::API::Result');
my @vars = $result->variables;
is_deeply([sort @vars], [qw(age hpage mbox name x)]);
my $x = $result->value('x');
does_ok($x, 'Attean::API::Blank');
is($x->value, 'r2');
my $age = $result->value('age');
does_ok($age, 'Attean::API::Literal');
is($age->value, '30');
is($age->datatype->value, 'http://www.w3.org/2001/XMLSchema#integer');
my $hpage = $result->value('hpage');
does_ok($hpage, 'Attean::API::IRI');
is($hpage->value, 'http://work.example.org/bob/');
});
$parser->parse_cb_from_bytes($json);
}
{
my $tsv = <<'END';
{
"head": { "vars": [ "x", "name" ]
} ,
"results": {
"bindings": [
{
"x": { "type": "bnode" , "value": "r2" } ,
"name": { "type": "literal" , "value": "Bob", "xml:lang": "en" }
},
{
"x": { "type": "uri" , "value": "http://example.org/eve" } ,
"name": { "type": "literal" , "value": "Eve" }
}
]
}
}
END
open(my $fh, '<', \$tsv);
my $counter = 0;
my $parser = Attean->get_parser('SPARQLJSON')->new(handler => sub {});
my @results = $parser->parse_list_from_io($fh);
is(scalar(@results), 2);
}
done_testing();
Attean-0.012/t/parser-sparqltsv.t 000644 000765 000024 00000003734 12651717125 017016 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
use autodie;
use Test::Modern;
use utf8;
use Attean;
sub iri { Attean::IRI->new(shift) }
sub blank { Attean::Blank->new(shift) }
sub literal {
my ($value, $lang, $dt) = @_;
if ($lang) {
return Attean::Literal->new(value => $value, language => $lang);
} elsif ($dt) {
return Attean::Literal->new(value => $value, datatype => $dt);
} else {
return Attean::Literal->new($value);
}
}
subtest 'parser construction and metadata' => sub {
my $parser = Attean->get_parser('SPARQLTSV')->new();
isa_ok($parser, 'AtteanX::Parser::SPARQLTSV');
is($parser->canonical_media_type, 'text/tab-separated-values', 'canonical_media_type');
my %extensions = map { $_ => 1 } @{ $parser->file_extensions };
ok(exists $extensions{'tsv'}, 'file_extensions');
my $type = $parser->handled_type;
can_ok($type, 'role');
is($type->role, 'Attean::API::Result');
};
{
my $tsv = <<'END';
?x ?hpage ?name ?age ?mbox ?friend
_:r2 "Bob"@en 30
END
my $counter = 0;
my $parser = Attean->get_parser('SPARQLTSV')->new(handler => sub {
$counter++;
my $result = shift;
does_ok($result, 'Attean::API::Result');
my @vars = $result->variables;
is_deeply([sort @vars], [qw(age hpage mbox name x)]);
my $x = $result->value('x');
does_ok($x, 'Attean::API::Blank');
is($x->value, 'r2');
my $age = $result->value('age');
does_ok($age, 'Attean::API::Literal');
is($age->value, '30');
is($age->datatype->value, 'http://www.w3.org/2001/XMLSchema#integer');
my $hpage = $result->value('hpage');
does_ok($hpage, 'Attean::API::IRI');
is($hpage->value, 'http://work.example.org/bob/');
});
$parser->parse_cb_from_bytes($tsv);
}
{
my $tsv = <<'END';
?x ?name
_:r2 "Bob"@en
"Eve"
END
open(my $fh, '<', \$tsv);
my $counter = 0;
my $parser = Attean->get_parser('SPARQLTSV')->new(handler => sub {});
my @results = $parser->parse_list_from_io($fh);
is(scalar(@results), 2);
}
done_testing();
Attean-0.012/t/parser-sparqlxml.t 000644 000765 000024 00000006251 12651717125 016777 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
use autodie;
use Test::More;
use utf8;
use Attean;
sub iri { Attean::IRI->new(shift) }
sub blank { Attean::Blank->new(shift) }
sub literal {
my ($value, $lang, $dt) = @_;
if ($lang) {
return Attean::Literal->new(value => $value, language => $lang);
} elsif ($dt) {
return Attean::Literal->new(value => $value, datatype => $dt);
} else {
return Attean::Literal->new($value);
}
}
subtest 'parser construction and metadata' => sub {
my $parser = Attean->get_parser('SPARQLXML')->new();
isa_ok($parser, 'AtteanX::Parser::SPARQLXML');
is($parser->canonical_media_type, 'application/sparql-results+xml', 'canonical_media_type');
my %extensions = map { $_ => 1 } @{ $parser->file_extensions };
ok(exists $extensions{'srx'}, 'file_extensions');
my $type = $parser->handled_type;
can_ok($type, 'role');
is($type->role, 'Attean::API::ResultOrTerm');
};
{
my $xml = <<'END';
r2
http://work.example.org/bob/
Bob
30
mailto:bob@work.example.org
END
my $counter = 0;
my $parser = Attean->get_parser('SPARQLXML')->new(handler => sub {
$counter++;
my $result = shift;
does_ok($result, 'Attean::API::Result');
my @vars = $result->variables;
is_deeply([sort @vars], [qw(age hpage mbox name x)]);
my $x = $result->value('x');
does_ok($x, 'Attean::API::Blank');
is($x->value, 'r2');
my $age = $result->value('age');
does_ok($age, 'Attean::API::Literal');
is($age->value, '30');
is($age->datatype->value, 'http://www.w3.org/2001/XMLSchema#integer');
my $hpage = $result->value('hpage');
does_ok($hpage, 'Attean::API::IRI');
is($hpage->value, 'http://work.example.org/bob/');
});
$parser->parse_cb_from_bytes($xml);
}
{
my $xml = <<'END';
r2
Bob
http://example.org/eve
Eve
END
open(my $fh, '<', \$xml);
my $counter = 0;
my $parser = Attean->get_parser('SPARQLXML')->new(handler => sub {});
my @results = $parser->parse_list_from_io($fh);
is(scalar(@results), 2);
}
done_testing();
sub does_ok {
my ($class_or_obj, $does, $message) = @_;
$message ||= "The object does $does";
ok(eval { $class_or_obj->does($does) }, $message);
}
Attean-0.012/t/parser-turtle.t 000644 000765 000024 00000005061 12652174223 016266 0 ustar 00greg staff 000000 000000 use v5.14;
use autodie;
use utf8;
use Test::Modern;
use Test::Exception;
use FindBin qw($Bin);
use File::Glob qw(bsd_glob);
use File::Spec;
use Attean;
use Attean::RDF;
use AtteanX::Parser::Turtle;
use AtteanX::Parser::Turtle::Constants;
use Type::Tiny::Role;
subtest 'parser construction and metadata' => sub {
my $parser = Attean->get_parser('Turtle')->new();
isa_ok($parser, 'AtteanX::Parser::Turtle');
is($parser->canonical_media_type, 'text/turtle', 'canonical_media_type');
my %extensions = map { $_ => 1 } @{ $parser->file_extensions };
ok(exists $extensions{'ttl'}, 'file_extensions');
my $type = $parser->handled_type;
can_ok($type, 'role');
is($type->role, 'Attean::API::Triple');
};
{
my $turtle = " 1, 2 .\n";
open(my $fh, '<', \$turtle);
my $parser = Attean->get_parser('Turtle')->new();
my $iter = $parser->parse_iter_from_io($fh);
does_ok($iter, 'Attean::API::Iterator');
is($iter->next->object->value, '1');
is($iter->next->object->value, '2');
is($iter->next, undef);
}
{
my $map = URI::NamespaceMap->new();
my $parser = Attean->get_parser('Turtle')->new( namespaces => $map );
my $content = <<'END';
@prefix ex: .
@prefix foaf: .
_:x a foaf:Person .
END
$parser->parse_cb_from_bytes($content, sub {});
is_deeply([sort $map->list_prefixes], [qw(ex foaf)]);
my $foaf = $map->namespace_uri('foaf');
isa_ok($foaf, 'URI::Namespace');
is($foaf->as_string, 'http://xmlns.com/foaf/0.1/');
}
subtest 'escaping' => sub {
my $turtle = q[ ex:p "\\"", '\\'', '\\u706b\\U0000661F' .];
open(my $fh, '<:encoding(UTF-8)', \$turtle);
my $l = AtteanX::Parser::Turtle::Lexer->new($fh);
expect($l->get_token, IRI, ['s'], 'subject');
expect($l->get_token, PREFIXNAME, ['ex:', 'p'], 'predicate');
expect($l->get_token, STRING1D, ['"'], 'double quote');
expect($l->get_token, COMMA, [',']);
expect($l->get_token, STRING1S, ["'"], 'single quote');
expect($l->get_token, COMMA, [',']);
expect($l->get_token, STRING1S, ["火星"], 'unicode \\u and \\U escapes');
};
subtest 'parse_term_from_bytes' => sub {
my $parser = Attean->get_parser('Turtle')->new();
my $turtle = '"""hello"""@en';
my $term = $parser->parse_term_from_bytes($turtle);
does_ok($term, 'Attean::API::Literal');
is($term->value, 'hello');
is($term->language, 'en');
};
done_testing();
sub expect {
my $token = shift;
my $type = shift;
my $values = shift;
my $name = shift // '';
if (length($name)) {
$name = "${name}: ";
}
is($token->type, $type, "${name}token type");
is_deeply($token->args, $values, "${name}token values");
}
Attean-0.012/t/parser.t 000644 000765 000024 00000005140 12546765300 014753 0 ustar 00greg staff 000000 000000 use v5.14;
use autodie;
use utf8;
use Test::More;
use Test::Exception;
use FindBin qw($Bin);
use File::Glob qw(bsd_glob);
use File::Spec;
use Attean;
my $p = Attean->get_parser('Turtle');
is($p, 'AtteanX::Parser::Turtle');
{
note('all acceptable parsers');
my $accept = Attean->acceptable_parsers();
ok(length($accept), 'got accept header value');
# check to make sure some of the default parsers are present:
like($accept, qr'text/turtle');
like($accept, qr'application/rdf[+]xml');
like($accept, qr'text/tab-separated-values');
}
{
note(' acceptable PULL parsers');
my $accept = Attean->acceptable_parsers(prefer => q[pull]);
# check to make sure some of the default parsers are present:
like($accept, qr'application/n-quads');
like($accept, qr'application/n-triples');
like($accept, qr'text/tab-separated-values');
unlike($accept, qr'application/rdf[+]xml');
}
{
note(' acceptable PUSH parsers');
my $accept = Attean->acceptable_parsers(prefer => q[Attean::API::PushParser]);
# check to make sure some of the default parsers are present:
like($accept, qr'text/turtle');
like($accept, qr'application/rdf[+]xml');
like($accept, qr'application/sparql-results[+]xml');
unlike($accept, qr'application/n-quads');
unlike($accept, qr'application/n-triples');
unlike($accept, qr'text/tab-separated-values');
}
{
note(' acceptable ATONCE parsers');
my $accept = Attean->acceptable_parsers(prefer => q[AtOnce]);
like($accept, qr'application/sparql-results[+]json');
unlike($accept, qr'text/turtle');
unlike($accept, qr'application/n-quads');
unlike($accept, qr'application/n-triples');
}
{
note(' acceptable SPARQL RESULT parsers');
my $accept = Attean->acceptable_parsers(handles => q[result]);
like($accept, qr'application/sparql-results[+]json');
like($accept, qr'application/sparql-results[+]xml');
like($accept, qr'text/tab-separated-values');
unlike($accept, qr'text/turtle');
unlike($accept, qr'application/rdf[+]xml');
unlike($accept, qr'application/n-quads');
unlike($accept, qr'application/n-triples');
}
{
note(' acceptable TRIPLE parsers');
my $accept = Attean->acceptable_parsers(handles => q[Attean::API::Triple]);
like($accept, qr'application/n-quads');
like($accept, qr'application/n-triples');
like($accept, qr'application/octet-stream');
like($accept, qr'application/x-turtle');
like($accept, qr'application/turtle');
like($accept, qr'text/turtle');
like($accept, qr'application/rdf[+]xml');
unlike($accept, qr'application/sparql-results[+]json');
unlike($accept, qr'application/sparql-results[+]xml');
unlike($accept, qr'text/tab-separated-values');
}
done_testing();
Attean-0.012/t/plan.t 000644 000765 000024 00000003064 12654422213 014405 0 ustar 00greg staff 000000 000000 use v5.14;
use autodie;
use utf8;
use Test::Modern;
use Test::Exception;
use Digest::SHA qw(sha1_hex);
use Attean;
use Attean::RDF;
use AtteanX::Store::Memory;
package TestPlanner {
use Moo;
extends 'Attean::QueryPlanner';
with 'Attean::API::NaiveJoinPlanner';
}
my $p = TestPlanner->new();
my $store = AtteanX::Store::Memory->new();
my $model = Attean::MutableQuadModel->new( store => $store );
my $graph = iri('http://example.org/');
my $t = triplepattern(variable('s'), iri('p'), literal('1'));
my $u = triplepattern(variable('s'), iri('p'), variable('o'));
my $v = triplepattern(variable('s'), iri('q'), blank('xyz'));
my $w = triplepattern(variable('a'), iri('b'), iri('c'));
my $x = triplepattern(variable('a'), variable('b'), iri('c'));
sub test_triples_for_connected_plan {
my $triples = shift;
my $connected = shift;
my $note = shift;
my $bgp = Attean::Algebra::BGP->new(triples => $triples);
my $plan = $p->plan_for_algebra($bgp, $model, [$graph]);
my $ok = $plan->subplans_of_type_are_variable_connected('Attean::Plan::Quad');
$ok = not($ok) unless ($connected);
ok($ok, $note);
}
test_triples_for_connected_plan([], 1, 'Empty BGP');
test_triples_for_connected_plan([$t], 1, '1-triple BGP');
test_triples_for_connected_plan([$t, $u], 1, '2-triple BGP');
test_triples_for_connected_plan([$w, $x], 1, '2-triple BGP');
test_triples_for_connected_plan([$t, $u, $v], 1, '3-triple BGP');
test_triples_for_connected_plan([$t, $u, $v, $w], 0, '4-triple BGP');
test_triples_for_connected_plan([$x, $t, $u, $v, $w], 0, '5-triple BGP');
done_testing();
Attean-0.012/t/serializer-canonicalntriples.t 000644 000765 000024 00000003703 12527736063 021344 0 ustar 00greg staff 000000 000000 use Test::More;
use Test::Exception;
use v5.14;
use warnings;
no warnings 'redefine';
use Attean;
use Attean::RDF;
use Encode;
use Type::Tiny::Role;
my $constraint = 'Attean::API::Triple';
my $p = iri('http://example.org/p');
my $ser = Attean->get_serializer('CanonicalNTriples')->new();
does_ok($ser, 'Attean::API::Serializer');
does_ok($ser, 'Attean::API::TripleSerializer');
isa_ok($ser, 'AtteanX::Serializer::NTriples');
{
my $t1 = triple(blank('x'), $p, Attean::Literal->integer(1));
my $t2 = triple(blank('x'), $p, Attean::Literal->integer(2));
my @triples = ($t1, $t2);
my $expected = <<"END";
_:v001 "1"^^ .
_:v001 "2"^^ .
END
my $i = Attean::ListIterator->new(values => [@triples], item_type => $constraint);
my $bytes = $ser->serialize_list_to_bytes(@triples);
my $data = decode('UTF-8', $bytes, Encode::FB_CROAK);
is($data, $expected, 'canonical serialize_iter_to_bytes 1');
}
{
my $x = blank('x');
my $y = blank();
my $t1 = triple($x, $p, Attean::Literal->integer(2));
my $t2 = triple($x, $p, $y);
my $t3 = triple($y, $p, $x);
my $t4 = triple($y, $p, Attean::Literal->integer(7));
my @triples = ($t1, $t2, $t3, $t4);
my $expected = <<"END";
_:v001 "2"^^ .
_:v001 _:v002 .
_:v002 "7"^^ .
_:v002 _:v001 .
END
my $i = Attean::ListIterator->new(values => [@triples], item_type => $constraint);
my $bytes = $ser->serialize_list_to_bytes(@triples);
my $data = decode('UTF-8', $bytes, Encode::FB_CROAK);
is($data, $expected, 'canonical serialize_iter_to_bytes 2');
}
done_testing();
sub does_ok {
my ($class_or_obj, $does, $message) = @_;
$message ||= "The object does $does";
ok(eval { $class_or_obj->does($does) }, $message);
}
Attean-0.012/t/serializer-nquads.t 000644 000765 000024 00000003705 12527736063 017131 0 ustar 00greg staff 000000 000000 use Test::More;
use Test::Exception;
use v5.14;
use warnings;
no warnings 'redefine';
use Attean;
use Type::Tiny::Role;
my $constraint = 'Attean::API::TripleOrQuad';
my $s = Attean::Blank->new('x');
my $p = Attean::IRI->new('http://example.org/p');
my $o1 = Attean::Literal->new(value => '1', datatype => 'http://www.w3.org/2001/XMLSchema#integer');
my $o2 = Attean::Literal->new(value => '2', datatype => 'http://www.w3.org/2001/XMLSchema#integer');
my $graph = Attean::IRI->new('http://example.org/default');
my $t1 = Attean::Triple->new($s, $p, $o1);
my $t2 = Attean::Quad->new($s, $p, $o2, $graph);
my @bindings = ($t1, $t2);
my $ser = Attean->get_serializer('NQuads')->new();
does_ok($ser, 'Attean::API::Serializer');
does_ok($ser, 'Attean::API::MixedStatementSerializer');
isa_ok($ser, 'AtteanX::Serializer::NQuads');
my $expected = <<"END";
_:x "1"^^ .
_:x "2"^^ .
END
{
my $i = Attean::ListIterator->new(values => [@bindings], item_type => $constraint);
my $data1 = $ser->serialize_iter_to_bytes($i);
my $data2 = $ser->serialize_list_to_bytes(@bindings);
is($data1, $expected, 'serialize_iter_to_bytes');
is($data1, $data2, 'serialize_list_to_bytes');
}
{
my $i = Attean::ListIterator->new(values => [@bindings], item_type => $constraint);
my $data = '';
open(my $fh, '>', \$data);
$ser->serialize_iter_to_io($fh, $i);
close($fh);
is($data, $expected, 'serialize_iter_to_io');
}
{
my $i = Attean::ListIterator->new(values => [@bindings], item_type => $constraint);
my $data = '';
open(my $fh, '>', \$data);
$ser->serialize_list_to_io($fh, @bindings);
close($fh);
is($data, $expected, 'serialize_iter_to_io');
}
done_testing();
sub does_ok {
my ($class_or_obj, $does, $message) = @_;
$message ||= "The object does $does";
ok(eval { $class_or_obj->does($does) }, $message);
}
Attean-0.012/t/serializer-ntriples.t 000644 000765 000024 00000003330 12651242417 017461 0 ustar 00greg staff 000000 000000 use Test::Modern;
use Test::Exception;
use v5.14;
use warnings;
no warnings 'redefine';
use Attean;
use Type::Tiny::Role;
my $constraint = 'Attean::API::Triple';
my $s = Attean::Blank->new('x');
my $p = Attean::IRI->new('http://example.org/p');
my $o1 = Attean::Literal->new(value => '1', datatype => 'http://www.w3.org/2001/XMLSchema#integer');
my $o2 = Attean::Literal->new(value => '2', datatype => 'http://www.w3.org/2001/XMLSchema#integer');
my $t1 = Attean::Triple->new($s, $p, $o1);
my $t2 = Attean::Triple->new($s, $p, $o2);
my @triples = ($t1, $t2);
{
my $ser = Attean->get_serializer('NTriples')->new();
does_ok($ser, 'Attean::API::Serializer');
does_ok($ser, 'Attean::API::TripleSerializer');
isa_ok($ser, 'AtteanX::Serializer::NTriples');
my $expected = <<"END";
_:x "1"^^ .
_:x "2"^^ .
END
{
my $i = Attean::ListIterator->new(values => [@triples], item_type => $constraint);
my $data1 = $ser->serialize_iter_to_bytes($i);
my $data2 = $ser->serialize_list_to_bytes(@triples);
is($data1, $expected, 'serialize_iter_to_bytes');
is($data1, $data2, 'serialize_list_to_bytes');
}
{
my $i = Attean::ListIterator->new(values => [@triples], item_type => $constraint);
my $data = '';
open(my $fh, '>', \$data);
$ser->serialize_iter_to_io($fh, $i);
close($fh);
is($data, $expected, 'serialize_iter_to_io');
}
{
my $i = Attean::ListIterator->new(values => [@triples], item_type => $constraint);
my $data = '';
open(my $fh, '>', \$data);
$ser->serialize_list_to_io($fh, @triples);
close($fh);
is($data, $expected, 'serialize_iter_to_io');
}
}
done_testing();
Attean-0.012/t/serializer-sparql.t 000755 000765 000024 00000101525 12654422213 017130 0 ustar 00greg staff 000000 000000 #!/usr/bin/env perl
use v5.14;
use autodie;
use utf8;
use Test::Modern;
use Test::Exception;
use Digest::SHA qw(sha1_hex);
use AtteanX::SPARQL::Constants;
use Attean;
use Attean::RDF;
subtest 'serializer construction and metadata' => sub {
my $ser = Attean->get_serializer('SPARQL')->new();
does_ok($ser, 'Attean::API::Serializer');
isa_ok($ser, 'AtteanX::Serializer::SPARQL');
is($ser->canonical_media_type, 'application/sparql-query', 'canonical_media_type');
my %types = map { $_ => 1 } @{ $ser->media_types };
ok(exists $types{'application/sparql-query'}, 'media_types');
my $type = $ser->handled_type;
can_ok($type, 'role');
is($type->role, 'AtteanX::SPARQL::Token');
my %extensions = map { $_ => 1 } @{ $ser->file_extensions };
ok(exists $extensions{'rq'}, 'file_extensions');
};
subtest 'sparql token as_string' => sub {
my $t = AtteanX::SPARQL::Token->fast_constructor(IRI, -1, -1, -1, -1, ['http://example.org/hello']);
is($t->as_string, 'IRI(http://example.org/hello)');
};
my $ser = Attean->get_serializer('SPARQL')->new();
subtest 'expected tokens: empty BGP tokens' => sub {
my $a = Attean::Algebra::BGP->new(triples => []);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
expect_token_stream($i, []);
ws_is($a->as_sparql, '');
};
subtest 'expected tokens: 1-triple BGP tokens' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $a = Attean::Algebra::BGP->new(triples => [$t]);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
expect_token_stream($i, [IRI, IRI, STRING1D, DOT]);
ws_is($a->as_sparql, ' "1" .');
};
subtest 'expected tokens: 2-BGP join tokens' => sub {
my $t = triplepattern(variable('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $a = Attean::Algebra::Join->new( children => [$bgp, $bgp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# { ?s
"1" . ?s
"1" . }
expect_token_stream($i, [LBRACE, VAR, IRI, STRING1D, DOT, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, '{ ?s
"1" . ?s
"1" . }');
};
subtest 'expected tokens: 2-triple BGP tokens with language and datatype' => sub {
my $t = triplepattern(variable('s'), iri('p'), Attean::Literal->new(value => '1', datatype => iri('http://example.org/type')));
my $u = triplepattern(variable('s'), iri('q'), Attean::Literal->new(value => 'hello', language => 'en-US'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t, $u]);
my $a = Attean::Algebra::Join->new( children => [$bgp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# { ?s
"1"^^ . ?s "1" . }
expect_token_stream($i, [LBRACE, VAR, IRI, STRING1D, HATHAT, IRI, DOT, VAR, IRI, STRING1D, LANG, DOT, RBRACE]);
ws_is($a->as_sparql, '{ ?s
"1"^^ . ?s "hello"@en-US . }');
};
subtest 'expected tokens: distinct/bgp' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $a = Attean::Algebra::Distinct->new( children => [$bgp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT DISTINCT * WHERE { "1" }
expect_token_stream($i, [KEYWORD, KEYWORD, STAR, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'SELECT DISTINCT * WHERE {
"1" . }');
};
subtest 'expected tokens: reduced/bgp' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $a = Attean::Algebra::Reduced->new( children => [$bgp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT REDUCED * WHERE {
"1" }
expect_token_stream($i, [KEYWORD, KEYWORD, STAR, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'SELECT REDUCED * WHERE {
"1" . }');
};
subtest 'expected tokens: bgp/limit' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $a = Attean::Algebra::Slice->new( children => [$bgp], limit => 5 );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT * WHERE {
"1" } LIMIT 5
expect_token_stream($i, [KEYWORD, STAR, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE, KEYWORD, INTEGER]);
ws_is($a->as_sparql, 'SELECT * WHERE {
"1" . } LIMIT 5');
};
subtest 'expected tokens: bgp/slice' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $a = Attean::Algebra::Slice->new( children => [$bgp], limit => 5, offset => 5 );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT * WHERE {
"1" } LIMIT 5 OFFSET 5
expect_token_stream($i, [KEYWORD, STAR, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE, KEYWORD, INTEGER, KEYWORD, INTEGER]);
ws_is($a->as_sparql, 'SELECT * WHERE {
"1" . } LIMIT 5 OFFSET 5');
};
subtest 'expected tokens: distinct/bgp/slice' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $dist = Attean::Algebra::Distinct->new( children => [$bgp] );
my $a = Attean::Algebra::Slice->new( children => [$dist], limit => 5, offset => 5 );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT DISTINCT * WHERE {
"1" } LIMIT 5 OFFSET 5
expect_token_stream($i, [KEYWORD, KEYWORD, STAR, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE, KEYWORD, INTEGER, KEYWORD, INTEGER]);
ws_is($a->as_sparql, 'SELECT DISTINCT * WHERE {
"1" . } LIMIT 5 OFFSET 5');
};
subtest 'property paths' => sub {
subtest 'expected tokens: predicate path' => sub {
my $p1 = iri('p1');
my $a = Attean::Algebra::PredicatePath->new( predicate => $p1 );
my $i = $a->sparql_tokens;
expect_token_stream($i, [IRI]);
subtest 'predicate path' => sub {
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' ');
}
};
subtest 'expected tokens: nps path' => sub {
my $p1 = iri('p1');
my $p2 = iri('p2');
my $a = Attean::Algebra::NegatedPropertySet->new( predicates => [$p1, $p2] );
my $i = $a->sparql_tokens;
# !(|)
expect_token_stream($i, [BANG, LPAREN, IRI, OR, IRI, RPAREN]);
subtest 'nps path' => sub {
my $a = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($a->as_sparql, ' !(|) ');
}
};
subtest 'expected tokens: 1-IRI sequence path' => sub {
my $p2 = iri('p2');
my $pp2 = Attean::Algebra::PredicatePath->new( predicate => $p2 );
my $a = Attean::Algebra::SequencePath->new( children => [$pp2] );
my $i = $a->sparql_tokens;
expect_token_stream($i, [IRI]);
subtest 'sequence path' => sub {
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' ');
}
};
subtest 'expected tokens: 2-IRI sequence path' => sub {
my $p1 = iri('p1');
my $p2 = iri('p2');
my $pp1 = Attean::Algebra::PredicatePath->new( predicate => $p1 );
my $pp2 = Attean::Algebra::PredicatePath->new( predicate => $p2 );
my $a = Attean::Algebra::SequencePath->new( children => [$pp1, $pp2] );
my $i = $a->sparql_tokens;
expect_token_stream($i, [IRI, SLASH, IRI]);
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' / ');
};
subtest 'expected tokens: 1-IRI alternative path' => sub {
my $p2 = iri('p2');
my $pp2 = Attean::Algebra::PredicatePath->new( predicate => $p2 );
my $a = Attean::Algebra::AlternativePath->new( children => [$pp2] );
my $i = $a->sparql_tokens;
expect_token_stream($i, [IRI]);
subtest 'alternative path' => sub {
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' ');
}
};
subtest 'expected tokens: 2-IRI alternative path' => sub {
my $p1 = iri('p1');
my $p2 = iri('p2');
my $pp1 = Attean::Algebra::PredicatePath->new( predicate => $p1 );
my $pp2 = Attean::Algebra::PredicatePath->new( predicate => $p2 );
my $a = Attean::Algebra::AlternativePath->new( children => [$pp1, $pp2] );
my $i = $a->sparql_tokens;
# |
expect_token_stream($i, [IRI, OR, IRI]);
subtest 'alternative path' => sub {
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' | ');
}
};
subtest 'expected tokens: 1-IRI inverse path' => sub {
my $p2 = iri('p2');
my $pp2 = Attean::Algebra::PredicatePath->new( predicate => $p2 );
my $a = Attean::Algebra::InversePath->new( children => [$pp2] );
my $i = $a->sparql_tokens;
# ^
expect_token_stream($i, [HAT, IRI]);
subtest 'inverse path' => sub {
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' ^ ');
}
};
subtest 'expected tokens: 2-IRI inverse path' => sub {
my $p1 = iri('p1');
my $p2 = iri('p2');
my $pp1 = Attean::Algebra::PredicatePath->new( predicate => $p1 );
my $pp2 = Attean::Algebra::PredicatePath->new( predicate => $p2 );
my $seq = Attean::Algebra::AlternativePath->new( children => [$pp1, $pp2] );
my $a = Attean::Algebra::InversePath->new( children => [$seq] );
my $i = $a->sparql_tokens;
# ^(|)
expect_token_stream($i, [HAT, LPAREN, IRI, OR, IRI, RPAREN]);
subtest 'inverse path' => sub {
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' ^(|) ');
}
};
subtest 'expected tokens: zero or more 2-IRI inverse path' => sub {
my $p1 = iri('p1');
my $p2 = iri('p2');
my $pp1 = Attean::Algebra::PredicatePath->new( predicate => $p1 );
my $pp2 = Attean::Algebra::PredicatePath->new( predicate => $p2 );
my $seq = Attean::Algebra::AlternativePath->new( children => [$pp1, $pp2] );
my $inv = Attean::Algebra::InversePath->new( children => [$seq] );
my $a = Attean::Algebra::ZeroOrMorePath->new( children => [$inv] );
my $i = $a->sparql_tokens;
# (^(/))*
expect_token_stream($i, [LPAREN, HAT, LPAREN, IRI, OR, IRI, RPAREN, RPAREN, STAR]);
subtest '* path' => sub {
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' (^(|))* ');
}
};
subtest 'expected tokens: one or more 2-IRI inverse path' => sub {
my $p1 = iri('p1');
my $p2 = iri('p2');
my $pp1 = Attean::Algebra::PredicatePath->new( predicate => $p1 );
my $pp2 = Attean::Algebra::PredicatePath->new( predicate => $p2 );
my $seq = Attean::Algebra::AlternativePath->new( children => [$pp1, $pp2] );
my $inv = Attean::Algebra::InversePath->new( children => [$seq] );
my $a = Attean::Algebra::OneOrMorePath->new( children => [$inv] );
my $i = $a->sparql_tokens;
# (^(/))+
expect_token_stream($i, [LPAREN, HAT, LPAREN, IRI, OR, IRI, RPAREN, RPAREN, PLUS]);
subtest '+ path' => sub {
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' (^(|))+ ');
}
};
subtest 'expected tokens: zero or one 2-IRI inverse path' => sub {
my $p1 = iri('p1');
my $p2 = iri('p2');
my $pp1 = Attean::Algebra::PredicatePath->new( predicate => $p1 );
my $pp2 = Attean::Algebra::PredicatePath->new( predicate => $p2 );
my $seq = Attean::Algebra::AlternativePath->new( children => [$pp1, $pp2] );
my $inv = Attean::Algebra::InversePath->new( children => [$seq] );
my $a = Attean::Algebra::ZeroOrOnePath->new( children => [$inv] );
my $i = $a->sparql_tokens;
# (^(/))+
expect_token_stream($i, [LPAREN, HAT, LPAREN, IRI, OR, IRI, RPAREN, RPAREN, QUESTION]);
subtest '? path' => sub {
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' (^(|))? ');
}
};
subtest 'expected tokens: 2-IRI sequence path triple' => sub {
my $p1 = iri('p1');
my $p2 = iri('p2');
my $pp1 = Attean::Algebra::PredicatePath->new( predicate => $p1 );
my $pp2 = Attean::Algebra::PredicatePath->new( predicate => $p2 );
my $seq = Attean::Algebra::SequencePath->new( children => [$pp1, $pp2] );
my $a = Attean::Algebra::Path->new( path => $seq, subject => iri('s'), object => iri('o') );
my $i = $a->sparql_tokens;
expect_token_stream($i, [IRI, IRI, SLASH, IRI, IRI]);
ws_is($a->as_sparql, ' / ');
};
};
subtest 'expected tokens: named graph tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triple(iri('s'), iri('p'), literal('1'))]);
my $g = iri('graphname');
my $a = Attean::Algebra::Graph->new( children => [$bgp], graph => $g );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# GRAPH { "1" . }
expect_token_stream($i, [KEYWORD, IRI, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'GRAPH { "1" . }');
};
subtest 'expected tokens: service tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triple(iri('s'), iri('p'), literal('1'))]);
my $g = iri('http://example.org/sparql');
my $a = Attean::Algebra::Service->new( children => [$bgp], endpoint => $g );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SERVICE { "1" . }
expect_token_stream($i, [KEYWORD, IRI, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'SERVICE { "1" . }');
};
subtest 'expected tokens: union tokens' => sub {
my $lhs = Attean::Algebra::BGP->new(triples => [triple(iri('s'), iri('p'), literal('1'))]);
my $rhs = Attean::Algebra::BGP->new(triples => [triple(iri('s'), iri('p'), literal('2'))]);
my $a = Attean::Algebra::Union->new( children => [$lhs, $rhs] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
expect_token_stream($i, [LBRACE, IRI, IRI, STRING1D, DOT, RBRACE, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, '{
"1" . } UNION {
"2" . }');
};
subtest 'expected tokens: minus tokens' => sub {
my $lhs = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $rhs = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('2'))]);
my $a = Attean::Algebra::Minus->new( children => [$lhs, $rhs] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# { ?s
"1" . } MINUS { ?s
"2" . }
expect_token_stream($i, [LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, '{ ?s
"1" . } MINUS { ?s
"2" . }');
};
subtest 'expected tokens: optional tokens' => sub {
my $lhs = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $rhs = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('2'))]);
my $a = Attean::Algebra::LeftJoin->new( children => [$lhs, $rhs] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# { ?s
"1" . } OPTIONAL { ?s
"1" . }
expect_token_stream($i, [LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, '{ ?s
"1" . } OPTIONAL { ?s
"2" . }');
};
subtest 'expected tokens: table tokens' => sub {
my @rows;
push(@rows, Attean::Result->new( bindings => { 's' => iri('http://example.org/') }));
push(@rows, Attean::Result->new( bindings => { 's' => literal('sparql') }));
my $a = Attean::Algebra::Table->new(variables => [variable('s')], rows => \@rows);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# VALUES (?s) { () ("sparql") }
expect_token_stream($i, [KEYWORD, LPAREN, VAR, RPAREN, LBRACE, LPAREN, IRI, RPAREN, LPAREN, STRING1D, RPAREN, RBRACE]);
ws_is($a->as_sparql, 'VALUES (?s) { () ("sparql") }');
};
subtest 'expected tokens: optional+filter tokens' => sub {
my $lhs = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $rhs = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('2'))]);
my $e = Attean::ValueExpression->new( value => variable('s') );
my $expr = Attean::FunctionExpression->new( operator => 'ISIRI', children => [$e] );
my $a = Attean::Algebra::LeftJoin->new( children => [$lhs, $rhs], expression => $expr );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# { ?s "1" . } OPTIONAL { ?s
"1" . FILTER(ISIRI(?s)) }
expect_token_stream($i, [LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, KEYWORD, LPAREN, KEYWORD, LPAREN, VAR, RPAREN, RPAREN, RBRACE]);
ws_is($a->as_sparql, '{ ?s
"1" . } OPTIONAL { ?s
"2" . FILTER(ISIRI(?s)) }');
};
subtest 'expected tokens: project' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $a = Attean::Algebra::Project->new( children => [$bgp], variables => [variable('p')] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT ?p WHERE { ?s
"1" . }
expect_token_stream($i, [KEYWORD, VAR, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'SELECT ?p WHERE { ?s
"1" . }');
};
subtest 'expected tokens: comparator tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $expr = Attean::ValueExpression->new( value => variable('s') );
my $a = Attean::Algebra::Comparator->new(ascending => 0, expression => $expr);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# DESC(?s)
expect_token_stream($i, [KEYWORD, LPAREN, VAR, RPAREN]);
};
subtest 'expected tokens: comparator tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $expr = Attean::ValueExpression->new( value => variable('s') );
my $cmp = Attean::Algebra::Comparator->new(ascending => 0, expression => $expr);
my $a = Attean::Algebra::OrderBy->new( children => [$bgp], comparators => [$cmp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT * WHERE { ?s
"1" . } ORDER BY DESC(?s)
expect_token_stream($i, [KEYWORD, STAR, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, KEYWORD, KEYWORD, KEYWORD, LPAREN, VAR, RPAREN]);
};
subtest 'expected tokens: ASK tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $a = Attean::Algebra::Ask->new( children => [$bgp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# ASK { ?s
"1" . }
expect_token_stream($i, [KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'ASK { ?s
"1" . }');
};
subtest 'expected tokens: CONSTRUCT tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $t = triplepattern(variable('s'), iri('q'), literal('2'));
my $a = Attean::Algebra::Construct->new( children => [$bgp], triples => [$t] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# CONSTRUCT { ?s "2" } WHERE { ?s "1" . }
expect_token_stream($i, [KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'CONSTRUCT { ?s "2" . } WHERE { ?s "1" . }');
};
subtest 'expected tokens: DESCRIBE tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $a = Attean::Algebra::Describe->new( children => [$bgp], terms => [variable('s'), iri('q')] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# DESCRIBE ?s WHERE { ?s "1" . }
expect_token_stream($i, [KEYWORD, VAR, IRI, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'DESCRIBE ?s WHERE { ?s "1" . }');
};
subtest 'expected tokens: project expressions tokens' => sub {
my $t1 = triplepattern(variable('s'), iri('p'), variable('o1'));
my $t2 = triplepattern(variable('s'), iri('q'), variable('o2'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t1, $t2]);
my $e1 = Attean::ValueExpression->new( value => variable('o1') );
my $e2 = Attean::ValueExpression->new( value => variable('o2') );
my $expr = Attean::BinaryExpression->new( operator => '+', children => [$e1, $e2] );
my $extend = Attean::Algebra::Extend->new(children => [$bgp], variable => variable('sum'), expression => $expr);
subtest 'project ordering 1' => sub {
my $a = Attean::Algebra::Project->new( children => [$extend], variables => [variable('s'), variable('sum')] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT ?s (?o1 + ?o2 AS ?sum) WHERE { ?s
?o1 . ?s ?o2 . }
expect_token_stream($i, [KEYWORD, VAR, LPAREN, VAR, PLUS, VAR, KEYWORD, VAR, RPAREN, KEYWORD, LBRACE, VAR, IRI, VAR, DOT, VAR, IRI, VAR, DOT, RBRACE]);
ws_is($a->as_sparql, 'SELECT ?s (?o1 + ?o2 AS ?sum) WHERE { ?s ?o1 . ?s ?o2 . }');
};
subtest 'project ordering 2' => sub {
my $a = Attean::Algebra::Project->new( children => [$extend], variables => [variable('sum'), variable('s')] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT (?o1 + ?o2 AS ?sum) ?s WHERE { ?s ?o1 . ?s ?o2 . }
expect_token_stream($i, [KEYWORD, LPAREN, VAR, PLUS, VAR, KEYWORD, VAR, RPAREN, VAR, KEYWORD, LBRACE, VAR, IRI, VAR, DOT, VAR, IRI, VAR, DOT, RBRACE]);
ws_is($a->as_sparql, 'SELECT (?o1 + ?o2 AS ?sum) ?s WHERE { ?s ?o1 . ?s ?o2 . }');
};
};
subtest 'expected tokens: binary filter tokens' => sub {
my $t1 = triplepattern(variable('s'), iri('p'), variable('o1'));
my $t2 = triplepattern(variable('s'), iri('q'), variable('o2'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t1, $t2]);
my $e1 = Attean::ValueExpression->new( value => variable('o1') );
my $e2 = Attean::ValueExpression->new( value => variable('o2') );
my $expr = Attean::BinaryExpression->new( operator => '>', children => [$e1, $e2] );
my $a = Attean::Algebra::Filter->new(children => [$bgp], expression => $expr);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# ?s ?o1 . ?s ?o2 . FILTER(?o1 > ?o2)
expect_token_stream($i, [VAR, IRI, VAR, DOT, VAR, IRI, VAR, DOT, KEYWORD, LPAREN, VAR, GT, VAR, RPAREN]);
};
subtest 'expected tokens: function filter tokens' => sub {
my $t = triplepattern(variable('s'), iri('p'), variable('o'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $e = Attean::ValueExpression->new( value => variable('o') );
my $expr = Attean::FunctionExpression->new( operator => 'ISIRI', children => [$e] );
my $a = Attean::Algebra::Filter->new(children => [$bgp], expression => $expr);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# ?s ?o . FILTER(ISIRI(?o))
expect_token_stream($i, [VAR, IRI, VAR, DOT, KEYWORD, LPAREN, KEYWORD, LPAREN, VAR, RPAREN, RPAREN]);
};
subtest 'expected tokens: cast filter tokens' => sub {
my $t = triplepattern(variable('s'), iri('p'), variable('o'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $e = Attean::ValueExpression->new( value => variable('o') );
my $expr = Attean::CastExpression->new( datatype => iri('http://www.w3.org/2001/XMLSchema#integer'), children => [$e] );
my $a = Attean::Algebra::Filter->new(children => [$bgp], expression => $expr);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# ?s
?o . FILTER((?o))
expect_token_stream($i, [VAR, IRI, VAR, DOT, KEYWORD, LPAREN, IRI, LPAREN, VAR, RPAREN, RPAREN]);
};
subtest 'expected tokens: exists filter tokens' => sub {
my $t = triplepattern(variable('s'), iri('p'), variable('o'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $u = triplepattern(variable('s'), iri('q'), literal('1'));
my $expr = Attean::ExistsExpression->new( pattern => Attean::Algebra::BGP->new(triples => [$u]) );
my $a = Attean::Algebra::Filter->new(children => [$bgp], expression => $expr);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# ?s ?o . FILTER( EXISTS { ?s "1" } )
expect_token_stream($i, [VAR, IRI, VAR, DOT, KEYWORD, LPAREN, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, RPAREN]);
};
subtest 'expected tokens: non-projected extend tokens' => sub {
my $t1 = triplepattern(variable('s'), iri('p'), variable('o1'));
my $t2 = triplepattern(variable('s'), iri('q'), variable('o2'));
my $bgp1 = Attean::Algebra::BGP->new(triples => [$t1, $t2]);
my $e1 = Attean::ValueExpression->new( value => variable('o1') );
my $e2 = Attean::ValueExpression->new( value => variable('o2') );
my $expr = Attean::BinaryExpression->new( operator => '+', children => [$e1, $e2] );
my $extend = Attean::Algebra::Extend->new(children => [$bgp1], variable => variable('sum'), expression => $expr);
subtest 'bare extend' => sub {
my $a = $extend;
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# ?s ?o1 . ?s ?o2 . BIND(?o1 + ?o2 AS ?sum)
expect_token_stream($i, [VAR, IRI, VAR, DOT, VAR, IRI, VAR, DOT, KEYWORD, LPAREN, VAR, PLUS, VAR, KEYWORD, VAR, RPAREN]);
};
subtest 'extend within projection' => sub {
my $t3 = triplepattern(variable('s'), iri('r'), variable('o3'));
my $bgp2 = Attean::Algebra::BGP->new(triples => [$t3]);
my $join = Attean::Algebra::Join->new( children => [$extend, $bgp2] );
my $a = Attean::Algebra::Project->new( children => [$join], variables => [variable('s'), variable('o3'), variable('sum')] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT ?s ?o3 ?sum WHERE { ?s ?o1 . ?s ?o2 . BIND(?o1 + ?o2 AS ?sum) ?s ?o3 }
expect_token_stream($i, [KEYWORD, VAR, VAR, VAR, KEYWORD, LBRACE, VAR, IRI, VAR, DOT, VAR, IRI, VAR, DOT, KEYWORD, LPAREN, VAR, PLUS, VAR, KEYWORD, VAR, RPAREN, VAR, IRI, VAR, DOT, RBRACE]);
};
};
subtest 'expected tokens: aggregation' => sub {
my $t = triplepattern(variable('s'), iri('p'), variable('o'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my @groups = Attean::ValueExpression->new( value => variable('s') );
my @aggs = Attean::AggregateExpression->new(
distinct => 0,
operator => 'SUM',
children => [Attean::ValueExpression->new( value => variable('o') )],
scalar_vars => {},
variable => variable("sum"),
);
my $a = Attean::Algebra::Group->new(
children => [$bgp],
groupby => \@groups,
aggregates => \@aggs,
);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT (SUM(?o) AS ?sum) WHERE { ?s ?o . } GROUP BY ?s
expect_token_stream($i, [KEYWORD, LPAREN, KEYWORD, LPAREN, VAR, RPAREN, KEYWORD, VAR, RPAREN, KEYWORD, LBRACE, VAR, IRI, VAR, DOT, RBRACE, KEYWORD, KEYWORD, VAR]);
};
# Attean::Algebra::Construct
# Attean::Algebra::Extend
# Attean::Algebra::Sequence
subtest 'BGP with blank' => sub {
my $b = blank('person');
my $rdf_type = iri('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
my $foaf_name = iri('http://xmlns.com/foaf/0.1/name');
my $foaf_knows = iri('http://xmlns.com/foaf/0.1/knows');
my $foaf_Person = iri('http://xmlns.com/foaf/0.1/Person');
my $bgp1 = Attean::Algebra::BGP->new( triples => [
triplepattern($b, $rdf_type, $foaf_Person),
triplepattern($b, $foaf_name, variable('name')),
triplepattern($b, $foaf_knows, variable('knows')),
] );
lives_ok {
my $string = $bgp1->as_sparql;
is($string, <<"END", 'expected serialization');
_:person .
_:person ?name .
_:person ?knows .
END
} 'as_sparql returns a string on blank';
};
done_testing();
exit;
{
note('BGP canonicalization');
my $b = blank('person');
my $rdf_type = iri('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
my $foaf_name = iri('http://xmlns.com/foaf/0.1/name');
my $foaf_knows = iri('http://xmlns.com/foaf/0.1/knows');
my $foaf_Person = iri('http://xmlns.com/foaf/0.1/Person');
my $bgp1 = Attean::Algebra::BGP->new( triples => [
triplepattern($b, $rdf_type, $foaf_Person),
triplepattern($b, $foaf_name, variable('name')),
triplepattern($b, $foaf_knows, variable('knows')),
] );
my $bgp2 = Attean::Algebra::BGP->new( triples => [
triplepattern(blank('s'), $foaf_knows, variable('person')),
triplepattern(blank('s'), $rdf_type, $foaf_Person),
triplepattern(blank('s'), $foaf_name, variable('myname')),
] );
my $hash1 = sha1_hex( join("\n", map { $_->tuples_string } (@{$bgp1->triples}) ) );
my $hash2 = sha1_hex( join("\n", map { $_->tuples_string } (@{$bgp2->triples}) ) );
isnt($hash1, $hash2, 'non-matching pre-canonicalized BGP hashes');
my ($cbgp1, $m1) = $bgp1->canonical_bgp_with_mapping;
my ($cbgp2, $m2) = $bgp2->canonical_bgp_with_mapping;
my $chash1 = sha1_hex( join("\n", map { $_->tuples_string } (@{$cbgp1->triples}) ) );
my $chash2 = sha1_hex( join("\n", map { $_->tuples_string } (@{$cbgp2->triples}) ) );
is($chash1, $chash2, 'matching canonicalized BGP hashes' );
is_deeply($m1, { '?name' => { 'prefix' => '?', 'id' => 'v003', 'type' => 'variable' }, '?knows' => { 'id' => 'v002', 'prefix' => '?', 'type' => 'variable' }, '_:person' => { 'id' => 'v001', 'prefix' => '_:', 'type' => 'blank' } }, 'BGP1 mapping');
is_deeply($m2, { '?person' => { 'prefix' => '?', 'id' => 'v002', 'type' => 'variable' }, '_:s' => { 'prefix' => '_:', 'id' => 'v001', 'type' => 'blank' }, '?myname' => { 'type' => 'variable', 'id' => 'v003', 'prefix' => '?' } }, 'BGP2 mapping');
}
{
my $t = triplepattern(variable('s'), iri('p'), variable('o'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my @groups = Attean::ValueExpression->new( value => variable('s') );
my @aggs = Attean::AggregateExpression->new(
distinct => 0,
operator => 'SUM',
children => [Attean::ValueExpression->new( value => variable('s') )],
scalar_vars => {},
variable => variable("sum"),
);
my $agg = Attean::Algebra::Group->new(
children => [$bgp],
groupby => \@groups,
aggregates => \@aggs,
);
my $s = $agg->as_string;
like($s, qr/Group [{] [?]s [}] aggregate [{] [?]sum ← SUM\([?]s\) [}]/, 'aggregate serialization');
}
{
note('Aggregation');
my $t = triplepattern(variable('s'), iri('p'), variable('o'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my @groups = Attean::ValueExpression->new( value => variable('s') );
my @aggs = Attean::AggregateExpression->new(
distinct => 0,
operator => 'SUM',
children => [Attean::ValueExpression->new( value => variable('s') )],
scalar_vars => {},
variable => variable("sum"),
);
my $agg = Attean::Algebra::Group->new(
children => [$bgp],
groupby => \@groups,
aggregates => \@aggs,
);
my $s = $agg->as_string;
like($s, qr/Group [{] [?]s [}] aggregate [{] [?]sum ← SUM\([?]s\) [}]/, 'aggregate serialization');
}
{
note('Ranking');
# RANKing example for 2 youngest students per school
my $bgp = Attean::Algebra::BGP->new(triples => [
triplepattern(variable('p'), iri('ex:name'), variable('name')),
triplepattern(variable('p'), iri('ex:school'), variable('school')),
triplepattern(variable('p'), iri('ex:age'), variable('age')),
]);
my @groups = Attean::ValueExpression->new( value => variable('school') );
my $r_agg = Attean::AggregateExpression->new(
distinct => 0,
operator => 'RANK',
children => [Attean::ValueExpression->new( value => variable('age') )],
scalar_vars => {},
variable => variable("rank"),
);
my $agg = Attean::Algebra::Group->new(
children => [$bgp],
groupby => \@groups,
aggregates => [$r_agg],
);
my $rank = Attean::Algebra::Filter->new(
children => [$agg],
expression => Attean::BinaryExpression->new(
children => [
Attean::ValueExpression->new( value => variable('rank') ),
Attean::ValueExpression->new( value => Attean::Literal->integer('2') ),
],
operator => '<='
),
);
my $s = $rank->as_string;
like($s, qr/Group [{] [?]school [}] aggregate [{] [?]rank ← RANK\([?]age\) [}]/, 'ranking serialization');
}
done_testing();
sub warn_token_stream {
my $i = shift;
while (my $t = $i->next) {
my $type = AtteanX::SPARQL::Constants::decrypt_constant($t->type);
my $value = $t->value;
warn sprintf("%-16s: %s\n", $type, $value);
}
}
sub expect_token_stream {
my $i = shift;
my $expect = shift;
while (my $t = $i->next) {
my $type = AtteanX::SPARQL::Constants::decrypt_constant($t->type);
is_token_of_type($t, shift(@$expect));
}
is(scalar(@$expect), 0);
}
sub is_token_of_type {
my $t = shift;
my $got = $t->type;
my $expect = shift;
if ($expect == A) {
Carp::confess;
}
my $got_name = AtteanX::SPARQL::Constants::decrypt_constant($got);
my $expect_name = AtteanX::SPARQL::Constants::decrypt_constant($expect);
if ($got == $expect) {
pass("Expected token type $got_name");
} else {
my $value = $t->value;
fail("Not expected token type (expected $expect_name, but got $got_name $value)");
}
}
sub ws_is {
my $got = shift;
my $expect = shift;
for ($got, $expect) {
chomp;
s/\s+//sg;
}
is($got, $expect);
}
Attean-0.012/t/serializer-sparqlcsv.t 000644 000765 000024 00000003775 12651242417 017654 0 ustar 00greg staff 000000 000000 use Test::Modern;
use Test::Exception;
use v5.14;
use warnings;
no warnings 'redefine';
use Attean;
use Attean::RDF;
use Type::Tiny::Role;
my $constraint = 'Attean::API::Result';
my $s = Attean::Blank->new('x');
my $p = Attean::IRI->new('http://example.org/p');
my $o1 = Attean::Literal->new(value => '1', datatype => 'http://www.w3.org/2001/XMLSchema#integer');
my $o2 = Attean::Literal->new(value => '2', language => 'en-US');
my $t1 = Attean::Result->new(bindings => { subject => $s, predicate => $p, object => $o1 });
my $t2 = Attean::Result->new(bindings => { subject => $s, predicate => $p, object => $o2 });
my $t3 = Attean::Result->new(bindings => { subject => iri('http://perlrdf.org/') });
my @triples = ($t1, $t2, $t3);
{
my $ser = Attean->get_serializer('SPARQLCSV')->new();
does_ok($ser, 'Attean::API::Serializer');
does_ok($ser, 'Attean::API::ResultSerializer');
isa_ok($ser, 'AtteanX::Serializer::SPARQLCSV');
my $expected = <<'END';
subject,predicate,object
_:x,http://example.org/p,1
_:x,http://example.org/p,2
http://perlrdf.org/,,
END
{
my $i = Attean::ListIterator->new(values => [@triples], item_type => $constraint, variables => [qw(subject predicate object)]);
my $b = $ser->serialize_iter_to_bytes($i);
is($b, $expected, 'serialize_iter_to_bytes');
}
{
my $i = Attean::ListIterator->new(values => [@triples], item_type => $constraint, variables => [qw(subject predicate object)]);
my $data = '';
open(my $fh, '>', \$data);
$ser->serialize_iter_to_io($fh, $i);
close($fh);
is($data, $expected, 'serialize_iter_to_io');
}
{
my $expected_reorder = <<'END';
predicate,subject,object
http://example.org/p,_:x,1
http://example.org/p,_:x,2
,http://perlrdf.org/,
END
my $i = Attean::ListIterator->new(values => [@triples], item_type => $constraint, variables => [qw(predicate subject object)]);
my $data = '';
open(my $fh, '>', \$data);
$ser->serialize_iter_to_io($fh, $i);
close($fh);
is($data, $expected_reorder, 'variable order sensitivity');
}
}
done_testing();
Attean-0.012/t/serializer-sparqlhtml.t 000644 000765 000024 00000006705 12652740134 020021 0 ustar 00greg staff 000000 000000 use Test::Modern;
use Test::Exception;
use v5.14;
use warnings;
no warnings 'redefine';
use Attean;
use Attean::RDF;
use Type::Tiny::Role;
my $constraint = 'Attean::API::Result';
my $s = Attean::Blank->new('x');
my $p = Attean::IRI->new('http://example.org/p');
my $o1 = Attean::Literal->new(value => '1', datatype => 'http://www.w3.org/2001/XMLSchema#integer');
my $o2 = Attean::Literal->new(value => '2', language => 'en-US');
my $t1 = Attean::Result->new(bindings => { subject => $s, predicate => $p, object => $o1 });
my $t2 = Attean::Result->new(bindings => { subject => $s, predicate => $p, object => $o2 });
my $t3 = Attean::Result->new(bindings => { subject => iri('http://perlrdf.org/') });
my @triples = ($t1, $t2, $t3);
{
my $ser = Attean->get_serializer('SPARQLHTML')->new();
does_ok($ser, 'Attean::API::Serializer');
does_ok($ser, 'Attean::API::ResultSerializer');
isa_ok($ser, 'AtteanX::Serializer::SPARQLHTML');
my $expected = <<'END';
?subject ?predicate ?object
_:x