rdf-rdfobjects 0.0.1

data/README

@@ -0,0 +1,64 @@
+RDF-RDFObjects: An Object Based Interface for RDF.rb.
+
+Usage:
+    
+    require 'rdf/rdfobjects'
+    
+    require 'rdf/ntriples'
+
+    graph = RDF::Graph.load("http://rdf.rubyforge.org/doap.nt")
+    
+    rdf = graph['http://rubygems.org/gems/rdf']
+    => #<RDF::URI:0x8143aba8(http://rubygems.org/gems/rdf)>
+    
+Properties can be accessed either via a hash syntax or dot syntax using RDF::Vocabulary constants:
+
+    rdf[DOAP.name]
+    => [#<RDF::Literal:0x81429c90("RDF.rb")>]
+    
+    rdf.DOAP.documenter
+    => [#<RDF::URI:0x81433254(http://ar.to/#self)>, #<RDF::URI:0x81432764(http://bhuga.net/#ben)>, #<RDF::URI:0x81431be8(http://kellogg-assoc.com/#me)>]
+    
+You can also return all the properties associated with a particular vocabulary:
+
+    rdf.DOAP
+    => {"http://usefulinc.com/ns/doap#maintainer"=>[#<RDF::URI:0x8142beb4(http://ar.to/#self)>, #<RDF::URI:0x8142b3c4(http://bhuga.net/#ben)>, #<RDF::URI:0x8142a848(http://kellogg-assoc.com/#me)>], "http://usefulinc.com/ns/doap#shortdesc"=>[#<RDF::Literal:0x814288cc("A Ruby library for working with Resource Description Framework (RDF) data."@en)>], "http://usefulinc.com/ns/doap#vendor"=>[#<RDF::URI:0x81428228(http://datagraph.org/)>], "http://usefulinc.com/ns/doap#created"=>[#<RDF::Literal:0x81436580("2007-10-23")>], "http://usefulinc.com/ns/doap#documenter"=>[#<RDF::URI:0x81433254(http://ar.to/#self)>, #<RDF::URI:0x81432764(http://bhuga.net/#ben)>, #<RDF::URI:0x81431be8(http://kellogg-assoc.com/#me)>], "http://usefulinc.com/ns/doap#platform"=>[#<RDF::Literal:0x814293bc("Ruby")>], "http://usefulinc.com/ns/doap#category"=>[#<RDF::URI:0x81437b88(http://dbpedia.org/resource/Resource_Description_Framework)>, #<RDF::URI:0x814370fc(http://dbpedia.org/resource/Ruby_(programming_language))>], "http://usefulinc.com/ns/doap#description"=>[#<RDF::Literal:0x81435a90("RDF.rb is a pure-Ruby library for working with Resource Description Framework (RDF) data."@en)>], "http://usefulinc.com/ns/doap#developer"=>[#<RDF::URI:0x814353ec(http://ar.to/#self)>, #<RDF::URI:0x814348fc(http://bhuga.net/#ben)>, #<RDF::URI:0x81433d80(http://kellogg-assoc.com/#me)>], "http://usefulinc.com/ns/doap#download-page"=>[#<RDF::URI:0x814310bc(http://rubyforge.org/projects/rdf/)>], "http://usefulinc.com/ns/doap#license"=>[#<RDF::URI:0x8142c940(http://creativecommons.org/licenses/publicdomain/)>], "http://usefulinc.com/ns/doap#blog"=>[#<RDF::URI:0x81439b90(http://ar.to/)>, #<RDF::URI:0x81439104(http://blog.datagraph.org/)>], "http://usefulinc.com/ns/doap#bug-database"=>[#<RDF::URI:0x81438614(http://github.com/bendiken/rdf/issues)>], "http://usefulinc.com/ns/doap#name"=>[#<RDF::Literal:0x81429c90("RDF.rb")>], "http://usefulinc.com/ns/doap#helper"=>[#<RDF::Node:0x81430630(_:genid1)>, #<RDF::Node:0x8142feec(_:genid2)>, #<RDF::Node:0x8142f7bc(_:genid3)>, #<RDF::Node:0x8142f08c(_:genid4)>, #<RDF::Node:0x8142e95c(_:genid5)>, #<RDF::Node:0x8142e22c(_:genid6)>, #<RDF::Node:0x8142dafc(_:genid7)>], "http://usefulinc.com/ns/doap#homepage"=>[#<RDF::URI:0x8142d3cc(http://rdf.rubyforge.org/)>]}
+    
+Related resources (besides literals) work the same way:
+
+    rdf.DOAP.helper.last.FOAF.name
+    => [#<RDF::Literal:0x8141f754("Pius Uzamere")>]
+
+All changes to properties on resources affect the graph that the resource belongs to.  All properties (even undefined ones) return an ObjectSet Array (which will be empty if the property is undefined).  Passing a Vocabulary reference will return an Assertion Set Hash.  The equals operator will replace all the statements in the graph that match the subject and predicate with the supplied object (or array of objects).
+
+    rdfobjects = graph.create('http://github.com/rsinger/rdf-rdfobjects')
+    => #<RDF::URI:0x8185c9ac(http://github.com/rsinger/rdf-rdfobjects)>
+    
+    rdfobjects.DOAP.maintainer << RDF::URI.new('http://dilettantes.code4lib.org/blog/about-me/#me')
+    => [#<RDF::URI:0x817aeb54(http://dilettantes.code4lib.org/blog/about-me/#me)>]
+
+    rdfobjects.DC.requires << rdf
+    => [#<RDF::URI:0x8143aba8(http://rubygems.org/gems/rdf)>]
+    
+    rdfobjects.DOAP.name
+    => []
+        
+    rdfobjects.DOAP.category = rdf.DOAP.category
+    => [#<RDF::URI:0x81437b88(http://dbpedia.org/resource/Resource_Description_Framework)>, #<RDF::URI:0x814370fc(http://dbpedia.org/resource/Ruby_(programming_language))>]
+    
+    rdfobjects.DOAP.category = rdf.DOAP.category.first
+    => #<RDF::URI:0x81437b88(http://dbpedia.org/resource/Resource_Description_Framework)>
+
+It also provides some convenience methods:
+
+    rdfobjects.predicates
+    => [#<RDF::URI:0x8172f5e8(http://purl.org/dc/terms/requires)>, #<RDF::URI:0x8145ce10(http://usefulinc.com/ns/doap#maintainer)>, #<RDF::URI:0x8146b514(http://usefulinc.com/ns/doap#category)>]
+    
+    rdfobjects.properties
+    => {#<RDF::URI:0x8172f5e8(http://purl.org/dc/terms/requires)>=>[#<RDF::URI:0x8143aba8(http://rubygems.org/gems/rdf)>], #<RDF::URI:0x8145ce10(http://usefulinc.com/ns/doap#maintainer)>=>[#<RDF::URI:0x817aeb54(http://dilettantes.code4lib.org/blog/about-me/#me)>], #<RDF::URI:0x8146b514(http://usefulinc.com/ns/doap#category)>=>[#<RDF::URI:0x81437b88(http://dbpedia.org/resource/Resource_Description_Framework)>]}
+    
+    rdfobjects.to_ntriples
+    => "<http://github.com/rsinger/rdf-rdfobjects> <http://purl.org/dc/terms/requires> <http://rubygems.org/gems/rdf> .\n<http://github.com/rsinger/rdf-rdfobjects> <http://usefulinc.com/ns/doap#maintainer> <http://dilettantes.code4lib.org/blog/about-me/#me> .\n<http://github.com/rsinger/rdf-rdfobjects> <http://usefulinc.com/ns/doap#category> <http://dbpedia.org/resource/Resource_Description_Framework> .\n"
+    
+.to_ntriples is also available on RDF::Graph.
+    

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/rdf/rdfobjects.rb

@@ -0,0 +1,28 @@
+require 'rdf' # @see http://rubygems.org/gems/rdf
+
+module RDF
+  module RDFObjects
+    autoload :VERSION, File.dirname(__FILE__) + '/rdfobjects/version'
+    autoload :AssertionSet, File.dirname(__FILE__) + '/rdfobjects/assertion_set'
+    autoload :Graph, File.dirname(__FILE__) + '/rdfobjects/graph'
+    autoload :ObjectSet, File.dirname(__FILE__) + '/rdfobjects/object_set'
+    autoload :Resource, File.dirname(__FILE__) + '/rdfobjects/resource'
+    autoload :Resource, File.dirname(__FILE__) + '/rdfobjects/resource'    
+  end
+  class URI
+    include RDFObjects::Resource
+    # Don't freeze the URIs.  Keep an eye on this, since, presumably, URIs are being frozen for a reason.
+    # However, we cannot add graphs to frozen objects and the ObjectStore complicates things.
+    def self.intern(str)
+      (cache[str = str.to_s] ||= self.new(str))
+    end      
+  end
+  
+  class Node
+    include RDFObjects::Resource
+  end
+    
+  class Graph
+    include RDFObjects::Graph
+  end    
+end # RDF

data/lib/rdf/rdfobjects/assertion_set.rb

@@ -0,0 +1,31 @@
+module RDF::RDFObjects
+  module AssertionSet
+    attr_reader :vocabulary, :subject
+    def vocabulary=(v)
+      @vocabulary = v
+    end
+    def subject=(s)
+      @subject=s
+    end
+    
+    def method_missing(meth, *args)
+      if meth.to_s =~ /\=$/
+        send(:set_property, @vocabulary.send(meth.to_s.sub(/\=$/,'').to_sym), args)
+      elsif prop = @vocabulary.send(meth)
+        send(:"[]", prop)       
+      end
+    end    
+    
+    def [](key)
+     if self.keys.index(key.to_s)
+       @subject[key]
+     else
+       send(:set_property, key, nil)
+     end
+    end
+    def set_property(p, args)
+      @subject[p] = args
+      @subject[p]
+    end
+  end
+end

data/lib/rdf/rdfobjects/graph.rb

@@ -0,0 +1,62 @@
+module RDF::RDFObjects
+  module Graph
+    def create(*args, &block)      
+      r = RDF::Resource.new(args.shift, *args, &block)
+      r.graph = self
+      r
+    end
+    
+    def [](id)
+      id = RDF::Resource.new(id) unless id.is_a?(Resource)
+      r = self.first_subject(:subject=>id)
+      r = self.first_object(:object=>id) unless r
+      r.graph = self if r
+      r
+    end
+    
+    def to_ntriples
+      RDF::Writer.for(:ntriples).buffer do |writer|
+        self.each_statement do |statement|
+          writer << statement
+        end
+      end
+    end
+    
+    def <<(data)
+      case data
+      when RDF::RDFObjects::Resource
+        data.statements.each do |stmt|
+          self.insert(stmt)
+        end
+      else
+        super(data)
+      end
+    end
+ 
+    def insert_statement(statement)
+      statement = statement.dup
+      statement.context = context
+      statement.each_triple.each do |s,p,o|
+        puts s.to_s
+        s.graph = self if s.is_a?(RDF::Resource)
+      end      
+      @data.insert(statement)
+    end    
+  end      
+end
+
+module RDF
+  class Graph
+    def insert_statement(statement)
+      statement = statement.dup
+      statement.context = context
+      statement.to_triple.each_cons(3) do |s,p,o|
+        s.graph = self
+        o.graph = self if o.is_a?(RDF::Resource) && !o.frozen?
+      end      
+      @data.insert(statement)
+    end      
+  end
+end
+
+

data/lib/rdf/rdfobjects/object_set.rb

@@ -0,0 +1,105 @@
+module RDF::RDFObjects   
+  module ObjectSet
+    attr_reader :subject, :predicate
+    def <<(o)
+      [*o].each do |object|
+        next unless object
+        @subject.push(@predicate, object)
+      end
+      self.replace(@subject[@predicate])
+    end
+    
+    def set_statement(stmt)
+      @subject = stmt.subject
+      @predicate = stmt.predicate
+    end
+    def clear
+      @subject[@predicate]=nil
+      super
+    end
+    def concat(ary)
+      ary.each do |i|
+        @subject.push(@predicate, i)
+      end
+      self.replace(@subject[@predicate])
+    end
+    
+    def delete(o)
+      d = super(o)
+      @subject.remove(@predicate, o)
+      d
+    end
+    
+    def delete_at(i)
+      d = super(i)
+      @subject.remove(@predicate, d) if d
+      d
+    end
+        
+    def fill(*args)
+      super(args)
+      @subject[@predicate]=self
+      @subject[@predicate]
+    end
+    def replace(ary)
+      obj_set=@subject[@predicate]=ary
+      super(obj_set)  
+    end  
+    
+    def insert(index, *obj)
+      super(index, obj)
+      @subject[@predicate]=self
+      self
+    end
+    
+    def pop(n=nil)
+      p = super(n)
+      [*p].each do |obj|
+        @subject.remove(@predicate, obj) if obj
+      end
+      self
+    end
+    
+    # def push(*obj)
+    #   super(obj)
+    #   @subject[@predicate] = self
+    #   self
+    # end
+    
+    def reverse!
+      super
+      @subject[@predicate] = self
+      self
+    end
+    
+    def rotate!(cnt=1)
+      super(cnt)
+      @subject[@predicate] = self
+      self
+    end      
+    
+    def shift(n=nil)
+      s = super(n)
+      @subject[@predicate] = self
+      s
+    end
+    
+    def shuffle!
+      super
+      @subject[@predicate] = self
+      self
+    end      
+    
+    def sort!
+      super
+      @subject[@predicate] = self
+      self
+    end
+    
+    def unshift(*obj)
+      super(obj)                  
+      @subject[@predicate] = self
+      self
+    end      
+  end
+end

data/lib/rdf/rdfobjects/resource.rb

@@ -0,0 +1,220 @@
+module RDF::RDFObjects
+  module Resource
+    attr_reader :graph
+    def graph=(graph)
+      @graph = graph
+    end
+    
+    def assert(p, o)
+      p = RDF::URI.intern(p) unless p.is_a?(RDF::URI)
+      unless o.is_a?(RDF::Resource) || o.is_a?(RDF::Literal)
+        o = RDF::Literal.new(o)
+      end
+      @graph << [self, p, o]
+    end
+    
+    def relate(p, o)
+      o = RDF::Resource.new(o) unless o.is_a?(RDF::Resource)
+      assert(p, o)
+    end
+
+    def [](p)
+      p = RDF::Resource.new(p) if p.is_a?(String)
+      results = {}
+      if p.is_a?(RDF::Resource)
+        if p == RDF.to_rdf
+          regex = Regexp.new(p.to_s)
+          if assertions
+            assertions.each_pair do |pred, objects|
+              results[pred.to_s] = objects if pred.to_s =~ /^#{regex}/
+            end 
+          end
+          results.extend(AssertionSet)
+          results.vocabulary = p
+          results.subject = self
+        else          
+          @graph.query(:subject=>self, :predicate=>p).each do |r|
+            if r.object.is_a?(RDF::Resource)
+              unless r.object.frozen?
+                r.object.extend(RDF::RDFObjects::Resource)
+                r.object.graph = self.graph
+              end
+            end
+            results[r.predicate] ||=[]
+            results[r.predicate] << r.object
+          end   
+        end               
+      elsif p.is_a?(Class) && p.inspect =~ /^RDF::Vocabulary\(/
+        regex = Regexp.new(p.to_s)
+        if assertions
+          assertions.each_pair do |pred, objects|
+            results[pred.to_s] = objects if pred.to_s =~ /^#{regex}/
+          end 
+        end
+        results.extend(AssertionSet)
+        results.vocabulary = p
+        results.subject = self
+        
+      elsif (RDF.const_defined?(p) && RDF.const_get(p).ancestors.index(RDF::Vocabulary))
+        regex = Regexp.new(RDF.const_get(p).to_s)
+        if assertions
+          assertions.each_pair do |pred, objects|
+            results[pred.to_s] = objects if pred.to_s =~ /^#{regex}/
+          end 
+        end
+        results.extend(AssertionSet)
+        results.vocabulary = RDF.const_get(p)         
+        results.subject = self
+      end
+      
+      if results.is_a?(AssertionSet)
+        results.each_pair do |pred, objs|
+          objs.extend(ObjectSet)
+          objs.set_statement(RDF::Statement.new(self, pred, ""))
+        end        
+        obj_set = results
+      else
+        obj_set = case results.keys.length
+        when 0
+          set = []
+          set.extend(ObjectSet)
+          set.set_statement(RDF::Statement.new(self,p,""))
+          set
+        when 1
+          set = []
+          results.values.first.each do |v|
+            set << v
+          end
+          set.extend(ObjectSet)
+          set.set_statement(RDF::Statement.new(self,p,""))
+          set
+        end
+      end
+      obj_set
+    end
+
+    def []=(p,o)      
+      p = RDF::URI.intern(p) unless p.is_a?(RDF::URI)
+      @graph.query(:subject=>self, :predicate=>p).each {|stmt| @graph.delete(stmt)}    
+      [*o].each do |obj|
+        next unless obj
+        obj = cast_as_typed_object(obj)        
+        if obj.is_a?(RDF::Resource) && !obj.frozen?
+          obj.graph = @graph
+        elsif obj.is_a?(RDF::Resource) && obj.frozen? && obj.graph != @graph
+          obj = RDF::URI.new(obj)
+          obj.graph = @graph
+          obj.freeze
+        end
+        @graph << [self, p, obj] unless obj.nil?
+      end
+      self[p]
+    end
+    
+    def remove(p, o=nil)
+      p = RDF::URI.intern(p) unless p.is_a?(RDF::URI)
+      removals = []
+      if o
+        o = cast_as_typed_object(o)
+        query = {:subject=>self, :predicate=>p, :object=>o}
+      else
+        query = {:subject=>self, :predicate=>p}
+      end
+      @graph.query(query).each do |stmt| 
+        removals << stmt
+        @graph.delete(stmt)
+      end      
+      if o
+        removals.first
+      else
+        removals
+      end
+    end
+
+    def push(p, o)
+      p = RDF::URI.intern(p) unless p.is_a?(RDF::URI)
+      o = cast_as_typed_object(o)
+      @graph << [self, p, o]
+    end
+    
+    def cast_as_typed_object(o)
+      return o if o.is_a?(RDF::Literal) || o.is_a?(RDF::Resource)
+      return Literal.new(o)
+    end
+    
+    def predicates
+      p = []
+      @graph.query(:subject=>self).each {|stmt| p << stmt.predicate unless p.include?(stmt.predicate)}
+      p
+    end
+    
+    def statements
+      stmts = []
+      @graph.query(:subject=>self, :predicate=>p).each {|stmt| stmts << stmt}   
+      stmts
+    end
+    
+    def object_of
+      subjects = []
+      @graph.query(:object=>self).each do |stmt|
+        s = stmt.subject
+        s.extend(RDF::RDFObjects::Resource)
+        s.graph = @graph
+        subjects << s
+      end
+      subjects
+    end
+    
+    def properties
+      results = {}
+      @graph.query(:subject=>self).each do |r| 
+        if r.object.is_a?(RDF::Resource)
+          r.object.graph = self.graph unless r.object.frozen?
+        end
+        results[r.predicate] ||=[]
+        results[r.predicate] << r.object
+      end
+      
+      obj_set = case results.keys.length
+      when 0 then nil
+      else
+        results.each_pair do |pred, objs|
+          #objs.each do |o|
+            objs.extend(ObjectSet)
+            objs.set_statement(RDF::Statement.new(self, pred, ""))
+          #end
+          #results[pred] = objs.first if objs.length == 1
+          results
+        end
+      end
+      obj_set      
+    end
+    alias :assertions :properties
+    
+    def type=(rdf_type)
+      self[RDF.type] = rdf_type
+    end
+    
+    def type
+      self[RDF.type]
+    end
+    
+    def clear
+      @graph.query(:subject=>self).each {|stmt| @graph.delete(stmt)}
+    end      
+    
+    def method_missing(meth, *args)
+      if RDF.const_defined?(meth) && RDF.const_get(meth).ancestors.index(RDF::Vocabulary)
+        send(:"[]", meth)
+      end
+    end
+
+    def to_ntriples
+      RDF::Writer.for(:ntriples).buffer do |writer|
+        @graph.query(:subject=>self).each_statement do |statement|
+          writer << statement
+        end
+      end      
+    end
+  end
+end  

data/lib/rdf/rdfobjects/uri.rb

@@ -0,0 +1,27 @@
+module RDF
+  class URI
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def self.cache
+      require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
+      @cache ||= {}
+      @cache[@graph] ||= RDF::Util::Cache.new(CACHE_SIZE)
+    end
+    
+    def self.intern(str)
+      (cache[@graph][str = str.to_s] ||= self.new(str)).freeze
+    end    
+    
+    def graph=(graph)
+      raise ArgumentError unless graph.is_a?(::RDF::Graph)
+      if !self.frozen? && graph != self.graph
+        @graph = graph
+      elsif self.frozen? && graph != self.graph
+        new_uri = self.dup
+        self = new_uri
+        @graph = graph
+      end        
+    end
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: rdf-rdfobjects
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ross Singer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-25 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 2
+        version: "2.2"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdf
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 0
+        - 3
+        - 1
+        version: 0.3.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id004
+description: An object oriented interface for working with Resource Description Framework (RDF) data in RDF.rb.
+email: rdfobjects@googlegroups.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- VERSION
+- lib/rdf/rdfobjects/assertion_set.rb
+- lib/rdf/rdfobjects/graph.rb
+- lib/rdf/rdfobjects/object_set.rb
+- lib/rdf/rdfobjects/resource.rb
+- lib/rdf/rdfobjects/uri.rb
+- lib/rdf/rdfobjects/version.rb
+- lib/rdf/rdfobjects.rb
+has_rdoc: false
+homepage: http://github.com/rsinger/rdf-rdfobjects
+licenses: 
+- Public Domain
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 53
+      segments: 
+      - 1
+      - 8
+      - 1
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An object oriented interface for working with Resource Description Framework (RDF) data in RDF.rb.
+test_files: []
+