lightrdf 0.1

data/History.txt

@@ -0,0 +1,3 @@
+=== 0.1 2010-10-06
+
+* Initial release

data/Manifest.txt

@@ -0,0 +1,12 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+bin/yarfp
+lib/lightrdf.rb
+lib/lightrdf/graph.rb
+lib/lightrdf/node.rb
+lib/lightrdf/parser.rb
+lib/lightrdf/quri.rb
+test/test_helper.rb
+test/test_lightrdf.rb

data/README.rdoc

@@ -0,0 +1,163 @@
+= LightRDF
+
+* http://github.com/josei/lightrdf
+
+== DESCRIPTION:
+
+LightRDF is a gem that makes managing RDF data and graphs easily with a Ruby interface.
+
+== INSTALL:
+
+  gem install lightrdf
+
+The gem also requires Raptor library (in Debian systems: sudo aptitude install raptor-utils), which is used
+for outputting different RDF serialization formats.
+
+Additionally, PNG output of RDF graphs requires Graphviz (in Debian systems: sudo aptitude install graphviz).
+
+== RDF NODES:
+
+RDF nodes can be created using the Node method:
+
+  a = Node('http://www.example.com/ontology#test')
+
+Namespaces can be defined in order to simplify URI manipulation:
+
+  Namespace :ex,   'http://www.example.com/ontology#'
+  a = Node('ex:test')
+
+BNodes can be created too:
+
+  bnode = Node('_:bnode1')
+
+BNode identifiers can be created automatically if a nil ID is supplied:
+
+  bnode = Node(nil)
+  puts bnode   # Outputs: _:1
+
+LightRDF's nodes are Ruby hashes that are evaluated as equal whenever their IDs are the same:
+
+  Node('_:bnode1')   == Node('_:bnode1')   # => true
+  Node('ex:example') == Node('ex:example') # => true
+
+== RDF TRIPLES:
+
+Triples can be created by creating relations between nodes.
+
+  user = Node('ex:bob')
+  user.foaf::name = "Bob"
+
+If you want to get the property, an array will be returned, as many foaf::name's can be associated to it:
+
+  user.foaf::name # => ["Bob"]
+
+Therefore, we can add multiple values to a property:
+
+  user.foaf::weblog = Node('http://www.awesomeweblogfordummies.com')
+  user.foaf::weblog << Node('http://www.anotherawesomeweblogfordummies.com')
+  user.foaf::weblog.size # => 2
+  user.foaf::weblog?(Node('http://www.awesomeweblogfordummies.com'))  # => true
+
+== RDF GRAPHS:
+
+Every node has an associated graph, where all its relations are stored.
+A node's own graph can be accessed by using node.graph.
+
+Graphs can also be created and merged:
+
+  alice = Node("ex:alice")
+  alice.foaf::name = "Alice"
+
+  bob = Node("ex:bob")
+  bob.foaf::name = "Bob"
+
+  graph = Graph.new # Creates a new empty graph
+  graph << alice    # Adds alice to the graph
+  graph[Node("ex:alice")].foaf::name # => ["Alice"]
+  graph[Node("ex:bob")].foaf::name # => []
+
+  merged_graph = graph.merge(bob.graph)
+  graph[Node("ex:alice")].foaf::name # => ["Alice"]
+  graph[Node("ex:bob")].foaf::name # => ["Bob"]
+  merged_graph.triples.size # => 2  
+
+Also, queries for triples can be performed on a graph:
+
+  a = Node('ex:bob')
+  a.foaf::name = "Bob"
+  a.foaf::age = "24"
+
+  b = Node('ex:alice')
+  b.foaf::name = "Alice"
+  b.foaf::age = "22"
+
+  g = RDF::Graph.new
+  g << a
+  g << b
+
+  # Find a person with age == 22
+  g.find(nil, Node('foaf:age'), "22") # => [Node('ex:bob')]
+
+  # Find all predicates bob has
+  g.find(Node('ex:bob'), nil, []) # => [Node('foaf:name'), Node('foaf:age')]
+
+== PARSING AND SERIALIZING:
+
+LightRDF uses Raptor library internally to support many RDF formats. It also introduces
+YARF (Yet Another RDF Format) for serializing and parsing. A YARF document is as follows:
+
+  # Namespaces
+  rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns#
+  rdfs: http://www.w3.org/2000/01/rdf-schema#
+  ex: http://www.example.com/ontology#
+  foaf: http://xmlns.com/foaf/0.1/
+  geo: http://www.w3.org/2003/01/geo/wgs84_pos#
+
+  # RDF data
+  ex:bob:
+    rdf:type: rdf:Resource
+    foaf:name: "Bob"
+    foaf:weblog:
+      http://www.awesomeblog.com:
+        dc:title: "Awesome blog"
+      http://www.anotherawesomeblog.com:
+        dc:title: "Another awesome blog"
+    foaf:based_near:
+      _:spain:   # Blank node with a specified id
+        geo:lat: "37.0625"
+      *:         # Blank node with auto generated id
+        geo:lat: "55.701"
+        geo:lng: "12.552"
+  _:spain:       # Blank node with an id can be referenced in the doc
+    geo:lng: "-95.677068"
+    
+Documents in either yarf, rdf, json, ejson (for easyJSON), dot, png, ntriples format can be parsed into
+graphs and serialized using the parse and serialize methods:
+
+  graph = RDF::Parser.parse(:rdf, open('http://planetrdf.com/guide/rss.rdf').read) # Builds a graph
+  graph.serialize(:ntriples) # Outputs a string with triples
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 José Ignacio Fernández (joseignacio.fernandez <at> gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/lightrdf'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'lightrdf' do
+  self.developer 'José Ignacio', 'joseignacio.fernandez@gmail.com'
+  self.summary = "Light and easy library for managing RDF data and graphs"
+  self.post_install_message = '**Remember to install raptor RDF tools and (optionally for RDF PNG output) Graphviz**'
+  self.rubyforge_name       = self.name # TODO this is default value
+  self.extra_deps         = [['activesupport','>= 2.0.2']]
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }

data/bin/yarfp

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'lightrdf'
+require 'open-uri'
+
+if $*.size < 1
+  puts 'YARF Parser'
+  puts 'Usage: yarfp URI_or_file [output_format] [input_format] [namespaces]'
+  puts ''
+  puts 'Available formats: yarf (default input), ntriples (default output), rdfxml, turtle, rdfa, dot, png'
+  puts 'Namespaces: prefix1,uri1,prefix2,uri2... e.g.: sc,http://lab.gsi.dit.upm.es/scrappy/schema.rdf#'
+  exit
+else
+  uri = $*[0]
+  output_format = ($*[1] || :ntriples).to_sym
+  input_format = ($*[2] || :yarf).to_sym
+end
+
+$*[3].split(',').each_slice(2) { |prefix, url| Namespace prefix, url } if $*[3]
+
+data = open(uri).read
+puts RDF::Parser.parse(input_format.to_sym, data).serialize(output_format.to_sym)

data/lib/lightrdf/graph.rb

@@ -0,0 +1,52 @@
+module RDF
+  class Graph < Hash
+    include Parser
+    # Namespace set stored when parsing a file. Can be used for reference
+    attr_accessor :ns
+    def initialize triples=[]
+      super(nil)
+      @ns = {}
+      self.triples = triples
+    end
+
+    def << node
+      self[node] = node
+    end
+
+    def [] id
+      super(ID(id)) || Node.new(id, self)
+    end
+    def []= id, node
+      node.graph = self
+      super ID(id), node
+    end
+    def nodes; values; end
+    def inspect
+      "{" + (values.map{|v| v.inspect} * ", ") + "}"
+    end
+    def merge graph
+      new_graph = Graph.new
+      new_graph.triples = triples + graph.triples
+      new_graph
+    end
+    def triples
+      triples = []; values.each { |n| triples += n.triples }
+      triples
+    end
+    def triples= triples
+      self.clear
+      triples.each { |s, p, o| self[s][p] = self[s][p] + [o] }
+    end
+    
+    def find subject, predicate, object
+      matches = triples.select { |s,p,o| (subject.nil? or subject==[] or s==subject) and
+                                         (predicate.nil? or predicate==[] or p==predicate) and
+                                         (object.nil? or object==[] or o==object) }
+      result = []
+      result += matches.map {|t| t[0] } if subject.nil?
+      result += matches.map {|t| t[1] } if predicate.nil?
+      result += matches.map {|t| t[2] } if object.nil?
+      result.uniq
+    end
+  end
+end

data/lib/lightrdf/node.rb

@@ -0,0 +1,84 @@
+module RDF
+  class NsProxy
+    undef :type
+    undef :class
+    undef :id
+    def initialize ns, object
+      @object = object
+      @ns = ns
+    end
+    def method_missing method, *args
+      if method.to_s =~ /.*=\Z/
+        @object["#{@ns}:#{method.to_s[0..-2]}"] = args.first
+      elsif method.to_s =~ /.*\?\Z/
+        @object["#{@ns}:#{method.to_s[0..-2]}"].include?(args.first)
+      else
+        @object["#{@ns}:#{method}"]
+      end
+    end
+  end
+
+  class Node < Hash
+    include Parser
+    attr_accessor :graph, :id
+
+    def initialize id=nil, graph=nil
+      @id = ID::parse(id)
+      @graph = graph || Graph.new
+      @graph << self
+    end
+
+    def method_missing method, *args
+      QURI.ns[method] ? NsProxy.new(method, self) : super
+    end
+    def inspect; "<#{self.class} #{id} #{super}>"; end
+    def to_s; id.to_s; end
+
+    def [] name
+      self[Node(name)] = [] if super(Node(name)).nil?
+      super(Node(name)).map! {|n| n.is_a?(Node) ? @graph[n] : n}
+    end
+    def []= name, values
+      super(Node(name), [values].flatten.map { |node| node.is_a?(Node) ? @graph[node] : node })
+    end
+
+    def == b
+      eql? b
+    end
+    def eql? b
+      b.is_a?(Node) and self.id == b.id
+    end
+    def hash # Hack for Ruby 1.8.6
+      id.hash + self.class.hash
+    end
+
+    def predicates
+      keys.map { |p| [ @graph[p], self[p] ] }
+    end
+
+    def triples
+      triples = []; each { |k, v| v.each { |o| triples << [self, Node(k), o] } }
+      triples
+    end
+    
+    def merge node
+      new_node = clone
+      (self.keys + node.keys).uniq.each do |k|
+        new_node[k] = (node[k] + self[k]).uniq
+      end
+      new_node
+    end
+
+    def clone
+      Node.new self
+    end
+
+    def bnode?
+      id.is_a?(BNodeID)
+    end    
+  end
+end
+
+def Node id, graph=nil
+  graph.nil? ? RDF::Node.new(id, graph) : graph[id]
+end

data/lib/lightrdf/parser.rb

@@ -0,0 +1,225 @@
+module RDF
+  module Parser
+    def to_ntriples; serialize :ntriples; end
+
+    def serialize format, header=true
+      nodes = if self.is_a?(Graph)
+        nodes_as_objects = find([], [], nil).select{|n| n.is_a?(Node)}
+        values - nodes_as_objects + nodes_as_objects # Put them at the end
+      else [self]
+      end
+
+      case format.to_sym
+      when :ntriples
+        triples.map { |s,p,o| "#{serialize_chunk_ntriples(s)} #{serialize_chunk_ntriples(p)} #{serialize_chunk_ntriples(o)} ." } * "\n"
+      when :yarf
+        ns = respond_to?(:ns) ? QURI.ns.merge(self.ns) : QURI.ns
+        if header
+          (ns.map{|k,v| "#{k}: #{v}\n"} * '') + serialize_yarf(nodes, ns)
+        else
+          serialize_yarf(nodes, ns)
+        end
+      when :ejson
+        stdin, stdout, stderr = Open3.popen3("python -mjson.tool")
+        stdin.puts ActiveSupport::JSON.encode(serialize_ejson(nodes))
+        stdin.close
+        stdout.read
+      when :png
+        dot = serialize(:dot)
+        ns = respond_to?(:ns) ? QURI.ns.merge(self.ns) : QURI.ns
+        ns.each { |k,v| dot.gsub!(v, "#{k}:") }
+        dot.gsub!(/label=\"\\n\\nModel:.*\)\";/, '')
+        stdin, stdout, stderr = Open3.popen3("dot -o/dev/stdout -Tpng")
+        stdin.puts dot
+        stdin.close
+        stdout.read
+      when :rdf
+        serialize(:rdfxml)
+      else
+        stdin, stdout, stderr = Open3.popen3("rapper -q -i ntriples -o #{format} /dev/stdin")
+        stdin.puts serialize(:ntriples)
+        stdin.close
+        stdout.read
+      end
+    end
+
+    def self.parse format, text
+      case format
+      when :ntriples
+        graph = RDF::Graph.new
+        graph.triples = text.split(".\n").map do |l|
+          s,p,o = l.strip.match(/(<.+>|".*"|_:.*)\W(<.+>|".*"|_:.*)\W(<.+>|".*"|_:.*)/).captures
+          [parse_chunk_ntriples(s), parse_chunk_ntriples(p), parse_chunk_ntriples(o)]
+        end
+        graph
+      when :yarf
+        graph = RDF::Graph.new
+        ns = {}
+        # Preprocessing - Extract namespaces, remove comments, get indent levels
+        lines = []
+        text.split("\n").each_with_index do |line, n|
+          if line =~ /(\A\s*#|\A\w*\Z)/ # Comment or blank line - do nothing
+          elsif line =~ /\A(\w+):\s+(.+)/ # Namespace
+            ns[$1.to_sym] = $2
+          else # Normal line - store line number, get indent level and strip line
+            lines << [n+1, (line.size - line.lstrip.size)/2,  line.strip]
+          end
+        end
+        parse_yarf_nodes lines, graph, ns
+        graph.ns = ns
+        graph
+      when :rdf
+        parse :rdfxml, text
+      when :ejson
+        raise Exception, "eJSON format cannot be parsed (yet)"
+      else
+        begin
+          stdin, stdout, stderr = Open3.popen3("rapper -q -i #{format} -o ntriples /dev/stdin")
+          stdin.puts text
+          stdin.close
+        rescue
+        end
+        parse :ntriples, stdout.read
+      end
+    end
+
+    private
+    def self.parse_yarf_nodes lines, graph, ns, base_level=0, i=0
+      nodes = []
+      while i < lines.size
+        number, level, line = lines[i]
+        if level == base_level
+          nodes << if line =~ /\A(".*")\Z/ # Literal
+            i += 1
+            ActiveSupport::JSON.decode($1)
+          elsif line =~ /\A(.+):\Z/ # Node with relations
+            node = Node(ID($1, ns), graph)
+            i, relations = parse_yarf_relations(lines, graph, ns, level+1, i+1)
+            relations.each { |predicate, object| node[predicate] = node[predicate] + [object] }
+            node
+          elsif line =~ /\A(.+)\Z/ # Node
+            i += 1
+            Node(ID($1, ns), graph)
+          else
+            raise Exception, "Syntax error on line #{number}"
+          end
+        elsif level < base_level
+          break
+        else
+          raise Exception, "Indentation error on line #{number}"
+        end
+      end
+      [i, nodes]
+    end
+    def self.parse_yarf_relations lines, graph, ns, base_level, i
+      relations = []
+      while i < lines.size
+        number, level, line = lines[i]
+        if level == base_level
+          relations += if line =~ /\A(.+):\s+(".+")\Z/ # Predicate and literal
+            i += 1
+            [[Node(ID($1, ns), graph), ActiveSupport::JSON.decode($2)]]
+          elsif line =~ /\A(.+):\s+(.+)\Z/ # Predicate and node
+            i += 1
+            [[Node(ID($1, ns), graph), Node(ID($2, ns), graph)]]
+          elsif line =~ /\A(.+):\Z/ # Just the predicate
+            predicate = Node(ID($1, ns), graph)
+            i, objects = parse_yarf_nodes(lines, graph, ns, level+1, i+1)
+            objects.map {|n| [predicate, n]}
+          end
+        elsif level < base_level
+          break
+        else
+          raise Exception, "Indentation error on line #{number}"
+        end
+      end
+      [i, relations]
+    end
+
+    def serialize_yarf nodes, ns=QURI.ns, level=0, already_serialized=[]
+      text = ""
+
+      for node in nodes
+        next if level == 0 and (node.triples.size == 0 or already_serialized.include?(node))
+        text += " " *level*2 
+        text += serialize_chunk_yarf(node, ns)
+        if already_serialized.include?(node) or !node.is_a?(Node) or node.triples.size == 0
+          text += "\n"
+        else
+          already_serialized << node
+          text += ":\n"
+          node.predicates.each do |p, o| # Predicate and object
+            text += " " *(level+1)*2
+            text += p.id.compressed(ns)
+            text += ":"
+            if o.size == 1 and (already_serialized.include?(o.first) or !o.first.is_a?(Node) or o.first.triples.size==0)
+              text += " " + serialize_chunk_yarf(o.first, ns)
+              text += "\n"
+            else
+              text += "\n" + serialize_yarf(o, ns, level+2, already_serialized)
+            end
+          end
+        end
+      end
+      text
+    end
+    
+    def serialize_chunk_yarf node, ns=QURI.ns
+      if node.is_a?(Node)
+        if node.bnode?
+          if node.graph.find(nil, [], node).size > 1 # Only use a bnode-id if it appears again as object
+            node.id.to_s
+          else
+            "*"
+          end
+        else
+          node.id.compressed ns
+        end
+      else
+        ActiveSupport::JSON.encode(node)
+      end
+    end
+
+    def serialize_ejson nodes, already_serialized=[], level=0
+      list = []
+
+      nodes.each do |n|
+        if n.is_a?(Node)
+          if already_serialized.include?(n)
+            list << { 'id' => n.to_s } unless level == 0
+          else
+            already_serialized << n
+            hash = { 'id' => n.to_s }
+            n.predicates.each do |k,v|
+              hash[k.to_s] = serialize_ejson(v, already_serialized, level+1)
+            end
+            list << hash
+          end
+        else
+          list << n.to_s
+        end
+      end
+
+      list
+    end
+
+    def serialize_chunk_ntriples n
+      if n.is_a? Node 
+        n.bnode? ? n.to_s : "<#{n}>"
+      else
+        ActiveSupport::JSON.encode(n)
+      end
+    end
+  
+    def self.parse_chunk_ntriples c
+      case c[0..0]
+      when '<' then Node c[1..-2]
+      when '_' then Node c
+      when '"' then
+        ActiveSupport::JSON.decode(c)
+      else
+        raise Exception, "Parsing error: #{c}"
+      end
+    end
+  end
+end

data/lib/lightrdf/quri.rb

@@ -0,0 +1,81 @@
+module RDF
+  module QURI
+    @ns = { :rdf  => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+            :rdfs => 'http://www.w3.org/2000/01/rdf-schema#',
+            :dc   => 'http://purl.org/dc/elements/1.1/',
+            :owl  => 'http://www.w3.org/2002/07/owl#' }
+    def self.ns; @ns; end
+
+    def self.parse uri, ns={}
+      URI.parse( (uri.to_s =~ /(\w+):(.*)/ and uri.to_s[0..6]!='http://' and uri.to_s[0..7]!='https://') ?
+                  "#{QURI.ns.merge(ns)[$1.to_sym]}#{$2}" :
+                  uri.to_s )
+    end
+
+    def self.compress uri, ns={}
+      QURI.ns.merge(ns).map.sort_by{|k,v| -v.to_s.size}.each do |k,v|
+        if uri.to_s.index(v) == 0
+          return "#{k}:#{uri.to_s[v.size..-1]}"
+        end
+      end
+      uri.to_s
+    end
+  end
+
+  module ID
+    def self.ns; QURI.ns; end
+
+    def compressed ns={}
+      RDF::ID.compress self, ns
+    end
+
+    def self.compress id, ns={}
+      bnode?(id) ? id.to_s : RDF::QURI.compress(id, ns)
+    end
+
+    def self.parse id, ns={}
+      bnode?(id) ? RDF::BNodeID.parse(id) : RDF::QURI.parse(id, ns)
+    end
+
+    def self.bnode?(id)
+      id.nil? or id == '*' or id.to_s[0..0] == '_'
+    end
+  end
+
+  class BNodeID
+    include RDF::ID
+    @count = 0
+    def self.count; @count; end
+    def self.count=c; @count=c; end
+
+    attr_reader :id
+    def initialize id=nil
+      @id = (id || "_:bnode#{RDF::BNodeID.count+=1}").to_s
+    end
+    def self.parse id
+      new(id=='*' ? nil : id)
+    end
+    def to_s; id.to_s; end
+
+    def == b
+      eql? b
+    end
+    def eql? b
+      b.is_a?(BNodeID) and self.id == b.id
+    end
+    def hash # Hack for Ruby 1.8.6
+      id.hash + self.class.hash
+    end
+  end
+end
+
+class URI::Generic
+  include RDF::ID # URIs are RDF IDs
+end
+
+def ID uri, ns={} # Shortcut to parse IDs
+  RDF::ID.parse uri, ns
+end
+def Namespace prefix, uri
+  RDF::QURI.ns[prefix.to_sym] = uri
+end

data/lib/lightrdf.rb

@@ -0,0 +1,17 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module RDF
+  VERSION = '0.1'
+end
+
+require 'rubygems'
+require 'active_support'
+require 'uri'
+require 'open3'
+require 'open-uri'
+
+require "lightrdf/quri"
+require "lightrdf/parser"
+require "lightrdf/graph"
+require "lightrdf/node"

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/lightrdf'

data/test/test_lightrdf.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestLightRDF < Test::Unit::TestCase
+
+  def setup
+    Namespace :ex,   'http://www.example.com/ontology#'
+    Namespace :foaf, 'http://xmlns.com/foaf/0.1/'
+  end
+  
+  def test_equality
+   assert Node('_:something') == Node(Node('_:something'))
+   assert ID('_:2') == ID('_:2')
+   assert ID('http://www.w3.org/1999/02/22-rdf-syntax-ns#type') == ID('rdf:type')
+   assert Node('_:2') == Node('_:2')
+  end
+
+  def test_type
+    assert ID('rdf:type').is_a?(RDF::ID)
+    assert ID('_:bnode').is_a?(RDF::ID)
+    assert ID('http://www.google.com').is_a?(RDF::ID)
+    assert URI.parse('http://www.google.com').is_a?(RDF::ID)
+    assert ID('*').is_a?(RDF::ID)
+  end
+
+  def test_random_node
+    assert Node(nil).is_a?(RDF::Node)
+  end
+
+  def test_graph
+    graph = RDF::Graph.new
+    assert_equal graph['rdf:type'], graph[Node('rdf:type')]
+    assert_equal graph['rdf:type'], graph['rdf:type']
+    assert_not_equal graph['foaf:name'], graph[Node('foaf::nick')]
+    assert_not_equal graph['rdf:type'], graph[Node('rdf:class')]
+    assert !graph['rdf:type'].eql?(graph[Node('rdf:class')])
+  end
+
+  def test_namespaces
+    assert_equal Node('http://www.example.com/ontology#test'), Node('ex:test')
+  end
+
+  def test_attributes
+    a = Node('ex:bob')
+    a.foaf::name = "Bob"
+    assert_equal "Bob", a.foaf::name.first
+  end
+
+  def test_query
+    a = Node('ex:bob')
+    a.foaf::name = "Bob"
+    a.foaf::age = "24"
+
+    b = Node('ex:alice')
+    b.foaf::name = "Alice"
+    b.foaf::age = "22"
+
+    g = RDF::Graph.new
+    g << a
+    g << b
+
+    assert_equal 1, g.find(nil, Node('foaf:age'), "22").size
+    assert_equal 2, g.find(Node('ex:bob'), nil, []).size
+  end
+
+  def test_addition
+    a = Node('ex:bob')
+    a.foaf::weblog = Node('http://www.awesomeweblogfordummies.com')
+    a.foaf::weblog << Node('http://www.anotherawesomeweblogfordummies.com')
+    assert_equal 2, a.foaf::weblog.size
+    assert a.foaf::weblog?(Node('http://www.awesomeweblogfordummies.com'))
+  end
+
+  def test_graph_merge
+    a = Node('ex:bob')
+    a.foaf::name = "Bob"
+
+    b = Node('ex:alice')
+    b.foaf::name = "Alice"
+
+    g1 = RDF::Graph.new
+    g2 = RDF::Graph.new
+    g1 << a
+    g2 << b
+
+    g3 = g1.merge(g2)
+
+    assert ["Alice"], g3[Node('ex:Alice')].foaf::name
+    assert ["Bob"], g3[Node('ex:bob')].foaf::name
+    assert_equal 2, g3.triples.size
+  end
+
+  def test_parsing
+    text = """
+dc: http://purl.org/dc/elements/1.1/
+rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns#
+ex: http://www.example.com/ontology#
+foaf: http://xmlns.com/foaf/0.1/
+*:
+  rdf:type: rdf:Resource
+  foaf:name: \"Bob\"
+  foaf:weblog:
+    \"http://www.awesomeweblogfordummies.com\"
+    http://www.anotherawesomeweblogfordummies.com:
+      dc:title: \"Another awesome blog\"
+"""
+
+    assert_equal 5, RDF::Parser.parse(:yarf, text).triples.size
+  end
+
+  def test_parsing_raptor
+    # Very naive testing -- it only helps to check that rapper is being executed
+    assert RDF::Parser.parse(:rdf, open('http://planetrdf.com/guide/rss.rdf').read).serialize(:ntriples).split("\n").size > 10
+  end
+
+  def test_serialization
+    a = Node('ex:bob')
+    a.foaf::name = "Bob"
+    a.foaf::age = "23"
+
+    g = RDF::Graph.new
+    g << a
+
+    assert 2, g.to_ntriples.split("\n").size
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: lightrdf
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- "Jos\xC3\xA9 Ignacio"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-06 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 2
+        version: 2.0.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id003
+description: LightRDF is a gem that makes managing RDF data and graphs easily with a Ruby interface.
+email: 
+- joseignacio.fernandez@gmail.com
+executables: 
+- yarfp
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- bin/yarfp
+- lib/lightrdf.rb
+- lib/lightrdf/graph.rb
+- lib/lightrdf/node.rb
+- lib/lightrdf/parser.rb
+- lib/lightrdf/quri.rb
+- test/test_helper.rb
+- test/test_lightrdf.rb
+has_rdoc: true
+homepage: http://github.com/josei/lightrdf
+licenses: []
+
+post_install_message: "**Remember to install raptor RDF tools and (optionally for RDF PNG output) Graphviz**"
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: lightrdf
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Light and easy library for managing RDF data and graphs
+test_files: 
+- test/test_lightrdf.rb
+- test/test_helper.rb