File Coverage

blib/lib/RDF/Query/Node/Variable.pm
Criterion Covered Total %
statement 57 66 86.3
branch 4 10 40.0
condition n/a
subroutine 19 22 86.3
pod 3 3 100.0
total 83 101 82.1


line stmt bran cond sub pod time code
1             # RDF::Query::Node::Variable
2             # -----------------------------------------------------------------------------
3              
4             =head1 NAME
5              
6             RDF::Query::Node::Variable - RDF Node class for variables
7              
8             =head1 VERSION
9              
10             This document describes RDF::Query::Node::Variable version 2.915_01.
11              
12             =cut
13              
14             package RDF::Query::Node::Variable;
15              
16 36     36   181 use strict;
  36         77  
  36         871  
17 36     36   180 use warnings;
  36         68  
  36         892  
18 36     36   177 no warnings 'redefine';
  36         65  
  36         1118  
19 36     36   172 use base qw(RDF::Query::Node RDF::Trine::Node::Variable);
  36         78  
  36         3854  
20              
21 36     36   201 use Data::Dumper;
  36         81  
  36         1772  
22 36     36   180 use Scalar::Util qw(blessed);
  36         83  
  36         1649  
23 36     36   203 use Carp qw(carp croak confess);
  36         83  
  36         2864  
24              
25             ######################################################################
26              
27             our ($VERSION);
28             BEGIN {
29 36     36   1872 $VERSION = '2.915_01';
30             }
31              
32             ######################################################################
33              
34             =head1 METHODS
35              
36             =head1 METHODS
37              
38             Beyond the methods documented below, this class inherits methods from the
39             L<RDF::Query::Node> and L<RDF::Trine::Node::Variable> classes.
40              
41             =over 4
42              
43             =cut
44              
45 36     36   204 use overload '""' => sub { $_[0]->sse };
  36     287   67  
  36         337  
  287         4480  
46              
47             =item C<< new ( $name ) >>
48              
49             Returns a new variable object.
50              
51             =cut
52              
53             my $COUNTER = 0;
54             sub new {
55 1021     1021 1 2358 my $class = shift;
56 1021         2120 my $name = shift;
57 1021 100       2512 unless (defined($name)) {
58 45         129 $name = 'v' . time() . 'r' . $COUNTER++;
59             }
60 1021         4123 return $class->SUPER::new( $name );
61             }
62              
63             =item C<< as_sparql >>
64              
65             Returns the SPARQL string for this node.
66              
67             =cut
68              
69             sub as_sparql {
70 381     381 1 2319 my $self = shift;
71 381         1130 return $self->sse;
72             }
73              
74             =item C<< as_hash >>
75              
76             Returns the query as a nested set of plain data structures (no objects).
77              
78             =cut
79              
80             sub as_hash {
81 0     0 1 0 my $self = shift;
82 0         0 my $context = shift;
83             return {
84 0         0 type => 'node',
85             variable => $self->name,
86             };
87             }
88              
89             package RDF::Query::Node::Variable::ExpressionProxy;
90              
91 36     36   7740 use strict;
  36         86  
  36         796  
92 36     36   182 use warnings;
  36         76  
  36         1034  
93 36     36   170 use base qw(RDF::Query::Node::Variable);
  36         107  
  36         2999  
94 36     36   191 use Scalar::Util qw(blessed refaddr);
  36         82  
  36         12095  
95              
96             =begin private
97              
98             =item C<< new >>
99              
100             =cut
101              
102             {my %vars;
103             sub new {
104 21     21   39 my $class = shift;
105 21         32 my $name = shift;
106 21         41 my @vars = @_;
107 21         62 my $self = $class->SUPER::new( $name );
108 21 50       154 if (@vars) {
109 21 50       39 $vars{ refaddr($self) } = [map {blessed($_) ? $_ : RDF::Query::Node::Variable->new($_)} @vars];
  21         172  
110             }
111 21         90 return $self;
112             }
113              
114             =item C<< as_sparql >>
115              
116             =cut
117              
118             sub as_sparql {
119 2     2   5 my $self = shift;
120 2         10 return $self->name;
121             }
122              
123             =item C<< referenced_variables >>
124              
125             =cut
126              
127             sub referenced_variables {
128 0     0   0 my $self = shift;
129 0 0       0 my @vars = map { blessed($_) ? $_->name : $_ } @{ $vars{ refaddr($self) } || [] };
  0 0       0  
  0         0  
130 0         0 return RDF::Query::_uniq(@vars);
131             }
132              
133             sub nonaggregated_referenced_variables {
134 0     0   0 return;
135             }
136              
137             sub DESTROY {
138 21     21   877 my $self = shift;
139 21         271 delete $vars{ refaddr($self) };
140             }
141             }
142              
143             =end private
144              
145             =cut
146              
147             1;
148              
149             __END__
150              
151             =back
152              
153             =head1 AUTHOR
154              
155             Gregory Todd Williams <gwilliams@cpan.org>
156              
157             =cut