=Paper=
{{Paper
|id=Vol-368/paper-15
|storemode=property
|title=Ruby Semantic Web Pipes
|pdfUrl=https://ceur-ws.org/Vol-368/paper14.pdf
|volume=Vol-368
}}
==Ruby Semantic Web Pipes==
<pdf width="1500px">https://ceur-ws.org/Vol-368/paper14.pdf</pdf>
<pre>
                        Ruby Semantic Web Pipes
                    Semantic Web Pipes just got easier

                            Daniel Hahn2 and Michele Barbera2

                             NET7 Internet Open Solutions - Pisa
                               (hahn|barbera)@netseven.it

    Ruby SemPipes are based on the Semantic Web Pipes proposed by Giovanni
Tummarello, Christian Morbidoni et. al. [1]. Semantic web pipes provide a mech-
anism similar to Yahoo! Pipes1 , but work on semantic web data. They allow users
to filter and recombine semantic web data on the fly (more information can be
found in the cited work). The original Semantic Pipes also have some advanced
features that are not touched here, such as the revocation of triples.
    Ruby SemPipes 2 . are an intentionally simple reimplementation of the Se-
mantic Web Pipes. They provide an easy “pipe description language” . Pipes
can easily be created and modified from a script or application, the definitions
are painless to read and they don’t require the pipe developer to manually edit
XML files or SPARQL queries.
    To make things simple, Ruby SemPipes treat all RDF graphs as enumera-
tions of triples. A pipe itself is also an enumeration over it’s result set and any
enumeration of triples (including other pipes) can be used as an input for a pipe.
    Using Eyal Oren’s ActiveRDF [2] library, it will be quite easy to provide
input adapters that connect to “real” RDF endpoints and perform SPARQL
queries. These adapters could then be used as input to a pipe. Conversely, output
adapters could re-write the result of a pipe to a common storage format, such
as RDF/XML.
    The first implementation of Ruby SemPipes contains a merge, filter and
rewrite operator; a smushing operator is in the pipeline. The filter and rewrite
operators allow a simple but powerful filtering (or rewriting) of triples using
regular expression. In addition to the operators, pipes may also contain actions
which allow the developer to manipulate triples programmatically. All built-in
operators are themselves pipes written in the same way as user-created pipes.
    Each pipe takes on ore more sets of RDF triples as an input; the pipe itself
will operate on the union (including duplicates) of the input sets – the merge
operator will actually just remove duplicates from the input.

                               Listing 1.1. Sample Pipe setup
module SemPipe
 # The f i r s t p i p e
  d e f i n e _ p i p e : new_pipe do
      m e r g e d _ t r i p l e s = merge ( i n p u t )
1
    http://pipes.yahoo.com/
2
    The first experimental version is available via public svn from http://svn.talia.
    discovery-project.eu/talia-intern/playground/ruby_pipes/trunk
     # R e w r i t e Tim Berners−Lee e n t r i e s
     r e w r i t t e n _ t r i p l e s = r e w r i t e ( m e r g e d _ t r i p l e s ) do
         rewrite : all ,
         "<h t t p : \ / \ / dbpedia . o r g \/ r e s o u r c e \/ Tim_Berners−Lee>" ,
         "<h t t p : / /www. w3 . o r g / P e o p l e / Berners −Lee / c a r d#i >"
     end

    # Remove a l l t r i p l e s d e a l i n g w i t h A l i c e
    s e l f . output = f i l t e r ( r e w r i t t e n _ t r i p l e s ) do
        r e j e c t : a l l "<h t t p : \ / \ / s t r a n g e w o r l d . com\\/ A l i c e "
    end
  end

  # Define another pipe
  d e f i n e _ p i p e : another_pipe do
     temp = new_pipe ( i n p u t )
      s e l f . output = a c t i o n ( temp ) do | i n p u t |
           i n p u t . to_a << [ @subject , @ p r e d i c a t e , @o b je ct ]
     end
  end

  # Use t h e p i p e
  AnotherPipe . new ( load_some_input ) . each { | t r i p l e | p u t s t r i p l e }
end
    Listing 1.1 shows a sample setup of two Ruby SemPipes. The first pipe merges
all input sets, then rewrites Tim Berners-Lee’s dbpedia URL with his own URL
and finally filters out all entries dealing with Alice. Pipes can be easily connected
using variables; the special variable input is used in the pipe description to
denote the pipe’s input. The self.output variable is used to assign a value to
the current pipe’s result set.
    The second pipe shows that other pipes can be used just as easily as the
built-in operators. The pipe also contains a generic action that adds a (complete
random) triple to the graph.

Acknowledgements
This work has been supported by Discovery, an ECP 2005 CULT 038206 project
under the EC eContentplus programme. Of course we also like to acknowledge
the original work of Christian and Giovanni.

References
1. Morbidoni, C., Polleres, A., Phuoc, D.L., Tummarello, G.: Semantic web pipes.
   Technical report, DERI (2007)
2. Oren, E., Debru, R., Gerke, S., Haller, A., Decker, S.: ActiveRDF: Object-Oriented
   Semantic Web Programming. In: 16th International World Wide Web Conference
   (WWW2007), Banff, Alberta, Canada. (8-12 May, 2007) 817–823

</pre>