ld4l-open_annotation_rdf 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88d80519b6716911be96e530e8d9d749fb164e21
-  data.tar.gz: e27c7e618cbdc975d45dee93aed8676614380831
+  metadata.gz: 4aa0556da41076b2f34c5e42dba07eae18293ab9
+  data.tar.gz: 602276cae0e89de7fb57d8c37ba15b9194d678b2
 SHA512:
-  metadata.gz: d17c5d27f63bd1ea4de5884cebef473438ff6fb853583ace7b4276b7cceda2bfaa0980546d9119b8fea137530664a23a9ef73408823d694c3a2831eae220f953
-  data.tar.gz: 6d8cdeaa648f3ff54dd0073add06286309c18b7331f514f62a5a860fee9a95c2833db944a65a17ec96b791ad72c03b4c1d099471f90117721e5218da2bf7c34d
+  metadata.gz: 4386b653e3aaa928613de1373228e541bb49d0aaee20681561eb367ec9c85e01a5e23616e1fea7d27f7389320b4f01b575dc4c25e431a92d3e66f0979c0eec62
+  data.tar.gz: 6728d645af71a8b61d67a574d413fc2fd2f377060b69bf1f992ed2b0bfe419f880fd4714da1a46c95bff0560a6ffe363906b1cef4ebc8b99c6ad13d7bacaaca0

data/.travis.yml

@@ -1,12 +1,16 @@
 language: ruby
 bundler_args: --without debug
 script: "bundle exec rspec spec"
+sudo: false
+cache: bundler
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
-  - 2.1.1
-  - jruby-19mode
+ - 2.1
+ - 2.2.2
+ - 2.2.4
+ - 2.3.1
+ - jruby-9.0.4.0
+ - rbx
 matrix:
   allow_failures:
-      - rvm: jruby-19mode
+      - rvm: jruby-9.0.4.0
+      - rvm: rbx

data/Gemfile

@@ -1,3 +1,6 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'activesupport', '< 5.0.0' if RUBY_VERSION =~ /2\.1\..*/
+gem 'pry-byebug' unless ENV["CI"]

data/README.md

@@ -25,6 +25,11 @@ Or install it yourself as:
     $ gem install ld4l-open_annotation_rdf
 
 
+## Primary Dependencies
+
+* [ActiveTriples 0.10.0](https://github.com/ActiveTriples/ActiveTriples/tree/v0.10.0)
+* [RDF 2.0.2](https://github.com/ruby-rdf/rdf/tree/2.0.2)
+
 ## Usage
 
 **Caveat:** This gem is part of the LD4L Project and is being used in that context.  There is no guarantee that the 

data/ld4l-open_annotation_rdf.gemspec

@@ -13,23 +13,19 @@ Gem::Specification.new do |spec|
   spec.description   = %q{LD4L Open Annotation RDF provides tools for modeling a annotations based on the Open Annotation ontology and persisting to a triplestore.}
   spec.homepage      = "https://github.com/ld4l/open_annotation_rdf"
   spec.license       = "APACHE2"
-  spec.required_ruby_version     = '>= 1.9.3'
+  spec.required_ruby_version     = '>= 2.1'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 
-  spec.add_dependency('rdf', '= 1.99.0')
-
-  spec.add_dependency('active-triples', '~> 0.5', '~> 0.6', '~>0.8.2')
+  spec.add_dependency('rdf')
+  spec.add_dependency('active-triples')
   spec.add_dependency('active_triples-local_name')
-  spec.add_dependency('ld4l-foaf_rdf', '~> 0.0')
+  spec.add_dependency('ld4l-foaf_rdf')
 
-  spec.add_development_dependency('pry')
-  spec.add_development_dependency('pry-byebug')
   spec.add_development_dependency('rdoc')
   spec.add_development_dependency('rspec')
   spec.add_development_dependency('coveralls')
-  spec.add_development_dependency('guard-rspec')
   spec.add_development_dependency('webmock')
 
   spec.extra_rdoc_files = [

data/lib/ld4l/open_annotation_rdf.rb

@@ -4,9 +4,6 @@ require 'active_triples/local_name'
 require	'linkeddata'
 require 'ld4l/foaf_rdf'
 require 'ld4l/open_annotation_rdf/version'
-require 'ld4l/open_annotation_rdf/vocab/oa'
-require 'ld4l/open_annotation_rdf/vocab/cnt'
-require 'ld4l/open_annotation_rdf/vocab/dctypes'
 
 
 module LD4L
@@ -29,38 +26,16 @@ module LD4L
       yield(configuration)
     end
 
-
-    # RDF vocabularies
-    autoload :OA,                    'ld4l/open_annotation_rdf/vocab/oa'
-    autoload :CNT,                   'ld4l/open_annotation_rdf/vocab/cnt'
-    autoload :DCTYPES,               'ld4l/open_annotation_rdf/vocab/dctypes'
-
-
     # autoload classes
     autoload :Configuration,         'ld4l/open_annotation_rdf/configuration'
     autoload :Annotation,            'ld4l/open_annotation_rdf/annotation'
+    autoload :AnnotationGenericBody, 'ld4l/open_annotation_rdf/annotation_generic_body'
     autoload :CommentAnnotation,     'ld4l/open_annotation_rdf/comment_annotation'
     autoload :CommentBody,           'ld4l/open_annotation_rdf/comment_body'
     autoload :TagAnnotation,         'ld4l/open_annotation_rdf/tag_annotation'
     autoload :TagBody,               'ld4l/open_annotation_rdf/tag_body'
     autoload :SemanticTagAnnotation, 'ld4l/open_annotation_rdf/semantic_tag_annotation'
     autoload :SemanticTagBody,       'ld4l/open_annotation_rdf/semantic_tag_body'
-
-    def self.class_from_string(class_name, container_class=Kernel)
-      container_class = container_class.name if container_class.is_a? Module
-      container_parts = container_class.split('::')
-      (container_parts + class_name.split('::')).flatten.inject(Kernel) do |mod, class_name|
-        if mod == Kernel
-          Object.const_get(class_name)
-        elsif mod.const_defined? class_name.to_sym
-          mod.const_get(class_name)
-        else
-          container_parts.pop
-          class_from_string(class_name, container_parts.join('::'))
-        end
-      end
-    end
-
   end
 end
 

data/lib/ld4l/open_annotation_rdf/annotation.rb

@@ -7,45 +7,30 @@ module LD4L
 
       @body = nil
 
-      configure :type => RDFVocabularies::OA.Annotation,
+      configure :type => RDF::Vocab::OA.Annotation,
                 :base_uri => LD4L::OpenAnnotationRDF.configuration.base_uri,
                 :repository => :default
 
-      property :hasTarget,   :predicate => RDFVocabularies::OA.hasTarget    # :type => URI
-      property :hasBody,     :predicate => RDFVocabularies::OA.hasBody
-      property :annotatedBy, :predicate => RDFVocabularies::OA.annotatedBy, :class_name => LD4L::FoafRDF::Person
-      property :annotatedAt, :predicate => RDFVocabularies::OA.annotatedAt, :cast => false   # :type => xsd:dateTime    # the time Annotation was created
-      property :motivatedBy, :predicate => RDFVocabularies::OA.motivatedBy, :cast => false   # comes from RDFVocabularies::OA ontology
+      property :hasTarget,   :predicate => RDF::Vocab::OA.hasTarget    # :type => URI
+      property :hasBody,     :predicate => RDF::Vocab::OA.hasBody
+      property :annotatedBy, :predicate => RDF::Vocab::OA.annotatedBy, :class_name => LD4L::FoafRDF::Person
+      property :annotatedAt, :predicate => RDF::Vocab::OA.annotatedAt, :cast => false   # :type => xsd:dateTime    # the time Annotation was created
+      property :motivatedBy, :predicate => RDF::Vocab::OA.motivatedBy, :cast => false   # comes from RDF::Vocab::OA ontology
 
       def self.resume(uri_or_str)
         # Let ActiveTriples::Resource validate uri_or_str when creating new Annotation
         a = new(uri_or_str)
+        return nil if a.nil?
 
-        # get motivatedBy
-        m = a.get_values(:motivatedBy)
-        m = m.to_a if Object.const_defined?("ActiveTriples::Relation") && m.kind_of?(ActiveTriples::Relation)
-
-        # TODO:  Should m's class be validated?  I've seen it be RDF::Vocabulary::Term and RDF::URI.  For now, removing the validation.
-        return a    unless m.kind_of?(Array) && m.size > 0
-        # return a    unless m.kind_of?(Array) && m.size > 0 && (m.first.kind_of?(RDF::Vocabulary::Term) || m.first.kind_of?(RDF::URI)
-
-        # motivatedBy is set
-        m_uri = m.first
         # currently only support commenting and tagging
-        return LD4L::OpenAnnotationRDF::CommentAnnotation.new(uri_or_str) if m_uri == RDFVocabularies::OA.commenting
-        return a                                                       unless m_uri == RDFVocabularies::OA.tagging
+        m = motivated_by a
+        return LD4L::OpenAnnotationRDF::CommentAnnotation.new(uri_or_str) if m.include? RDF::Vocab::OA.commenting
 
         # Tagging can be TagAnnotation or SemanticTagAnnotation.  Only way to tell is by checking type of body.
-        sta = LD4L::OpenAnnotationRDF::SemanticTagAnnotation.new(uri_or_str)
-        stb = sta.getBody
-        return sta                          unless stb.type.include?(RDFVocabularies::OA.Tag) || !stb.type.include?(RDFVocabularies::OA.SemanticTag)
-
-        ta = LD4L::OpenAnnotationRDF::TagAnnotation.new(uri_or_str)
-        tb = ta.getBody
-        return ta                           if tb.type.include?(RDFVocabularies::OA.Tag)
-
-        # can't match to a known annotation type, so return as generic annotation
-        return a
+        return a unless m.include? RDF::Vocab::OA.tagging
+        b = body_resource a
+        return LD4L::OpenAnnotationRDF::TagAnnotation.new(uri_or_str) if b.type.include? RDF::Vocab::OA.Tag
+        LD4L::OpenAnnotationRDF::SemanticTagAnnotation.new(uri_or_str)
       end
 
       ##
@@ -98,8 +83,8 @@ module LD4L
         repo = ActiveTriples::Repositories.repositories[repository]
         query = RDF::Query.new({
                                    :annotation => {
-                                       RDF.type =>  RDFVocabularies::OA.Annotation,
-                                       RDFVocabularies::OA.hasTarget => target_uri,
+                                       RDF.type =>  RDF::Vocab::OA.Annotation,
+                                       RDF::Vocab::OA.hasTarget => target_uri,
                                    }
                                })
         annotations = []
@@ -107,6 +92,19 @@ module LD4L
         results.each { |r| annotations << r.to_hash[:annotation] }
         annotations
       end
+
+      private
+        def self::motivated_by annotation
+          m = annotation.get_values(:motivatedBy).to_a
+          return nil unless m.kind_of?(Array) && (m.size > 0)
+          m
+        end
+
+        def self::body_resource annotation
+          body_uris = annotation.hasBody
+          return nil if body_uris.nil? || body_uris.size < 1
+          AnnotationGenericBody.new(body_uris.first)  # TODO: a full implementation of OA could have multiple bodies
+        end
     end
   end
 end

data/lib/ld4l/open_annotation_rdf/annotation_generic_body.rb

@@ -0,0 +1,12 @@
+module LD4L
+  module OpenAnnotationRDF
+    class AnnotationGenericBody < ActiveTriples::Resource
+
+      class << self; attr_reader :localname_prefix end
+      @localname_prefix="a"
+
+      configure :base_uri => LD4L::OpenAnnotationRDF.configuration.base_uri,
+                :repository => :default
+    end
+  end
+end

data/lib/ld4l/open_annotation_rdf/comment_annotation.rb

@@ -4,13 +4,10 @@ module LD4L
 
       @localname_prefix="ca"
 
-      configure :type => RDFVocabularies::OA.Annotation,
+      configure :type => RDF::Vocab::OA.Annotation,
                 :base_uri => LD4L::OpenAnnotationRDF.configuration.base_uri,
                 :repository => :default
 
-      property :hasBody, :predicate => RDFVocabularies::OA.hasBody, :class_name => LD4L::OpenAnnotationRDF::CommentBody
-
-
       ##
       # Create a comment annotation body and set the hasBody property to it.
       #
@@ -53,8 +50,8 @@ module LD4L
 
         # set motivatedBy
         m = get_values(:motivatedBy)
-        m = m.to_a if Object.const_defined?("ActiveTriples::Relation") && m.kind_of?(ActiveTriples::Relation)
-        set_value(:motivatedBy, RDFVocabularies::OA.commenting) unless m.kind_of?(Array) && m.size > 0
+        m = m.to_a if Object::ActiveTriples.const_defined?("Relation") && m.kind_of?(ActiveTriples::Relation)
+        set_value(:motivatedBy, RDF::Vocab::OA.commenting) unless m.kind_of?(Array) && m.size > 0
 
         # resume CommentBody if it exists
         comment_uri = get_values(:hasBody).first

data/lib/ld4l/open_annotation_rdf/comment_body.rb

@@ -5,18 +5,18 @@ module LD4L
       class << self; attr_reader :localname_prefix end
       @localname_prefix="cb"
 
-      configure :type => RDFVocabularies::CNT.ContentAsText,
+      configure :type => RDF::Vocab::CNT.ContentAsText,
                 :base_uri => LD4L::OpenAnnotationRDF.configuration.base_uri,
                 :repository => :default
 
-      property :content, :predicate => RDFVocabularies::CNT.chars,  :cast => false  # :type => XSD.string
-      property :format,  :predicate => RDF::DC.format,              :cast => false  # :type => XSD.string
+      property :content, :predicate => RDF::Vocab::CNT.chars,  :cast => false  # :type => XSD.string
+      property :format,  :predicate => RDF::Vocab::DC.format,              :cast => false  # :type => XSD.string
 
       def initialize(*args)
         super(*args)
 
         t = get_values(:type)
-        t << RDFVocabularies::DCTYPES.Text
+        t << RDF::Vocab::DCMIType.Text
         set_value(:type,t)
       end
     end

data/lib/ld4l/open_annotation_rdf/semantic_tag_annotation.rb

@@ -4,13 +4,10 @@ module LD4L
 
       @localname_prefix = "sta"
 
-      configure :type => RDFVocabularies::OA.Annotation,
+      configure :type => RDF::Vocab::OA.Annotation,
                 :base_uri => LD4L::OpenAnnotationRDF.configuration.base_uri,
                 :repository => :default
 
-      property :hasBody, :predicate => RDFVocabularies::OA.hasBody, :class_name => LD4L::OpenAnnotationRDF::SemanticTagBody
-
-
       # USAGE: Use setTerm to set the hasBody property to be the URI of the controlled vocabulary term that
       #        is the annotation.
 
@@ -59,8 +56,8 @@ module LD4L
 
         # set motivatedBy
         m = get_values(:motivatedBy)
-        m = m.to_a if Object.const_defined?("ActiveTriples::Relation") && m.kind_of?(ActiveTriples::Relation)
-        set_value(:motivatedBy, RDFVocabularies::OA.tagging) unless m.kind_of?(Array) && m.size > 0
+        m = m.to_a if Object::ActiveTriples.const_defined?("Relation") && m.kind_of?(ActiveTriples::Relation)
+        set_value(:motivatedBy, RDF::Vocab::OA.tagging) unless m.kind_of?(Array) && m.size > 0
 
         # resume SemanticTagBody if it exists
         term_uri = get_values(:hasBody).first

data/lib/ld4l/open_annotation_rdf/semantic_tag_body.rb

@@ -8,7 +8,7 @@ module LD4L
       # USAGE: When creating a semantic tag body, use the URI of the controlled vocabulary term as the RDF Subject URI
       #        for an instance of this class.
 
-      configure :type => RDFVocabularies::OA.SemanticTag,
+      configure :type => RDF::Vocab::OA.SemanticTag,
                 :base_uri => LD4L::OpenAnnotationRDF.configuration.base_uri,
                 :repository => :default
 
@@ -30,8 +30,8 @@ module LD4L
         repo = ActiveTriples::Repositories.repositories[repository]
         query = RDF::Query.new({
                                    :annotation => {
-                                       RDF.type =>  RDFVocabularies::OA.Annotation,
-                                       RDFVocabularies::OA.hasBody => term_uri,
+                                       RDF.type =>  RDF::Vocab::OA.Annotation,
+                                       RDF::Vocab::OA.hasBody => term_uri,
                                    }
                                })
         annotations = []

data/lib/ld4l/open_annotation_rdf/tag_annotation.rb

@@ -4,12 +4,10 @@ module LD4L
 
       @localname_prefix="ta"
 
-      configure :type => RDFVocabularies::OA.Annotation,
+      configure :type => RDF::Vocab::OA.Annotation,
                 :base_uri => LD4L::OpenAnnotationRDF.configuration.base_uri,
                 :repository => :default
 
-      property :hasBody,  :predicate => RDFVocabularies::OA.hasBody,   :class_name => LD4L::OpenAnnotationRDF::TagBody
-
       # TODO: Should a tag be destroyed when the last annotation referencing the tag is destroyed?
 
       ##
@@ -102,8 +100,8 @@ module LD4L
 
         # set motivatedBy
         m = get_values(:motivatedBy)
-        m = m.to_a if Object.const_defined?("ActiveTriples::Relation") && m.kind_of?(ActiveTriples::Relation)
-        set_value(:motivatedBy, RDFVocabularies::OA.tagging) unless m.kind_of?(Array) && m.size > 0
+        m = m.to_a if Object::ActiveTriples.const_defined?("Relation") && m.kind_of?(ActiveTriples::Relation)
+        set_value(:motivatedBy, RDF::Vocab::OA.tagging) unless m.kind_of?(Array) && m.size > 0
 
         # resume TagBody if it exists
         tag_uri = get_values(:hasBody).first

data/lib/ld4l/open_annotation_rdf/tag_body.rb

@@ -5,11 +5,11 @@ module LD4L
       class << self; attr_reader :localname_prefix end
       @localname_prefix="tb"
 
-      configure :type => RDFVocabularies::OA.Tag,
+      configure :type => RDF::Vocab::OA.Tag,
                 :base_uri => LD4L::OpenAnnotationRDF.configuration.base_uri,
                 :repository => :default
 
-      property :tag,     :predicate => RDFVocabularies::CNT.chars,   :cast => false  # :type => XSD.string
+      property :tag,     :predicate => RDF::Vocab::CNT.chars,   :cast => false  # :type => XSD.string
 
       ##
       # Get a list of annotations using the tag value.
@@ -31,8 +31,8 @@ module LD4L
         repo = ActiveTriples::Repositories.repositories[repository]
         query = RDF::Query.new({
                                    :annotation => {
-                                       RDF.type =>  RDFVocabularies::OA.Annotation,
-                                       RDFVocabularies::OA.hasBody => tag_uri,
+                                       RDF.type =>  RDF::Vocab::OA.Annotation,
+                                       RDF::Vocab::OA.hasBody => tag_uri,
                                    }
                                })
         results = query.execute(repo)
@@ -57,8 +57,8 @@ module LD4L
         repo = ActiveTriples::Repositories.repositories[repository]
         query = RDF::Query.new({
           :tagbody => {
-            RDF.type =>  RDFVocabularies::OA.Tag,
-            RDFVocabularies::CNT.chars => tag_value,
+            RDF.type =>  RDF::Vocab::OA.Tag,
+            RDF::Vocab::CNT.chars => tag_value,
           }
         })
 
@@ -76,7 +76,7 @@ module LD4L
         super(*args)
 
         t = get_values(:type)
-        t << RDFVocabularies::CNT.ContentAsText
+        t << RDF::Vocab::CNT.ContentAsText
         set_value(:type,t)
       end
     end

data/lib/ld4l/open_annotation_rdf/version.rb

@@ -1,5 +1,5 @@
 module LD4L
   module OpenAnnotationRDF
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/spec/ld4l/open_annotation_rdf/annotation_spec.rb

@@ -2,6 +2,10 @@ require 'spec_helper'
 
 describe 'LD4L::OpenAnnotationRDF::Annotation' do
 
+  after do
+    ActiveTriples::Repositories.repositories[LD4L::OpenAnnotationRDF::CommentAnnotation.repository].clear!
+  end
+
   subject { LD4L::OpenAnnotationRDF::Annotation.new }
 
   describe 'rdf_subject' do
@@ -21,9 +25,9 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
 
     describe 'when changing subject' do
       before do
-        subject << RDF::Statement.new(subject.rdf_subject, RDF::DC.title, RDF::Literal('Comet in Moominland'))
-        subject << RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.isPartOf, subject.rdf_subject)
-        subject << RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.relation, 'http://example.org/moomin_land')
+        subject << RDF::Statement.new(subject.rdf_subject, RDF::Vocab::DC.title, RDF::Literal('Comet in Moominland'))
+        subject << RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::Vocab::DC.isPartOf, subject.rdf_subject)
+        subject << RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::Vocab::DC.relation, 'http://example.org/moomin_land')
         subject.set_subject! RDF::URI('http://example.org/moomin')
       end
 
@@ -33,15 +37,15 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
       end
 
       it 'should update graph subjects' do
-        expect(subject.has_statement?(RDF::Statement.new(subject.rdf_subject, RDF::DC.title, RDF::Literal('Comet in Moominland')))).to be true
+        expect(subject.has_statement?(RDF::Statement.new(subject.rdf_subject, RDF::Vocab::DC.title, RDF::Literal('Comet in Moominland')))).to be true
       end
 
       it 'should update graph objects' do
-        expect(subject.has_statement?(RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.isPartOf, subject.rdf_subject))).to be true
+        expect(subject.has_statement?(RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::Vocab::DC.isPartOf, subject.rdf_subject))).to be true
       end
 
       it 'should leave other uris alone' do
-        expect(subject.has_statement?(RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.relation, 'http://example.org/moomin_land'))).to be true
+        expect(subject.has_statement?(RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::Vocab::DC.relation, 'http://example.org/moomin_land'))).to be true
       end
     end
 
@@ -62,8 +66,8 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
   # -------------------------------------------------
 
   describe 'type' do
-    it "should be an RDFVocabularies::OA.Annotation" do
-      expect(subject.type.first.value).to eq RDFVocabularies::OA.Annotation.value
+    it "should be an RDF::Vocab::OA.Annotation" do
+      expect(subject.type.first.value).to eq RDF::Vocab::OA.Annotation.value
     end
   end
 
@@ -150,14 +154,14 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
     end
 
     it "should be settable" do
-      subject.motivatedBy = RDFVocabularies::OA.describing
-      expect(subject.motivatedBy.first).to eq RDFVocabularies::OA.describing
+      subject.motivatedBy = RDF::Vocab::OA.describing
+      expect(subject.motivatedBy.first).to eq RDF::Vocab::OA.describing
     end
 
     it "should be changeable" do
-      subject.motivatedBy = RDFVocabularies::OA.describing
-      subject.motivatedBy = RDFVocabularies::OA.classifying
-      expect(subject.motivatedBy.first).to eq RDFVocabularies::OA.classifying
+      subject.motivatedBy = RDF::Vocab::OA.describing
+      subject.motivatedBy = RDF::Vocab::OA.classifying
+      expect(subject.motivatedBy.first).to eq RDF::Vocab::OA.classifying
     end
   end
 
@@ -190,12 +194,12 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
         expect(a.hasTarget.first.rdf_subject.to_s).to eq "http://example.org/bibref/br3"
         expect(a.annotatedBy.first).to eq a_person
         expect(a.annotatedAt.first).to eq a_time
-        expect(a.motivatedBy.first).to eq RDFVocabularies::OA.commenting
+        expect(a.motivatedBy.first).to eq RDF::Vocab::OA.commenting
 
         b = a.getBody
         expect(b).to be_a_kind_of(LD4L::OpenAnnotationRDF::CommentBody)
-        expect(b.type).to include RDFVocabularies::DCTYPES.Text
-        expect(b.type).to include RDFVocabularies::CNT.ContentAsText
+        expect(b.type).to include RDF::Vocab::DCMIType.Text
+        expect(b.type).to include RDF::Vocab::CNT.ContentAsText
         expect(b.content).to eq ["This is a comment."]
         expect(b.format.first).to eq "text/plain"
       end
@@ -216,12 +220,12 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
         expect(a.hasTarget.first.rdf_subject.to_s).to eq "http://example.org/bibref/br3"
         expect(a.annotatedBy.first).to eq a_person
         expect(a.annotatedAt.first).to eq a_time
-        expect(a.motivatedBy.first).to eq RDFVocabularies::OA.tagging
+        expect(a.motivatedBy.first).to eq RDF::Vocab::OA.tagging
 
         b = a.getBody
         expect(b).to be_a_kind_of(LD4L::OpenAnnotationRDF::TagBody)
-        expect(b.type).to include RDFVocabularies::OA.Tag
-        expect(b.type).to include RDFVocabularies::CNT.ContentAsText
+        expect(b.type).to include RDF::Vocab::OA.Tag
+        expect(b.type).to include RDF::Vocab::CNT.ContentAsText
         expect(b.tag).to eq ["good"]
       end
 
@@ -241,11 +245,11 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
         expect(a.hasTarget.first.rdf_subject.to_s).to eq "http://example.org/bibref/br3"
         expect(a.annotatedBy.first).to eq a_person
         expect(a.annotatedAt.first).to eq a_time
-        expect(a.motivatedBy.first).to eq RDFVocabularies::OA.tagging
+        expect(a.motivatedBy.first).to eq RDF::Vocab::OA.tagging
 
         b = a.getBody
         expect(b).to be_a_kind_of(LD4L::OpenAnnotationRDF::SemanticTagBody)
-        expect(b.type).to include RDFVocabularies::OA.SemanticTag
+        expect(b.type).to include RDF::Vocab::OA.SemanticTag
         expect(b.rdf_subject.to_s).to eq('http://example.org/term/3')
       end
     end
@@ -274,12 +278,12 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
         expect(a.hasTarget.first.rdf_subject.to_s).to eq "http://example.org/bibref/br3"
         expect(a.annotatedBy.first).to eq a_person
         expect(a.annotatedAt.first).to eq a_time
-        expect(a.motivatedBy.first).to eq RDFVocabularies::OA.commenting
+        expect(a.motivatedBy.first).to eq RDF::Vocab::OA.commenting
 
         b = a.getBody
         expect(b).to be_a_kind_of(LD4L::OpenAnnotationRDF::CommentBody)
-        expect(b.type).to include RDFVocabularies::DCTYPES.Text
-        expect(b.type).to include RDFVocabularies::CNT.ContentAsText
+        expect(b.type).to include RDF::Vocab::DCMIType.Text
+        expect(b.type).to include RDF::Vocab::CNT.ContentAsText
         expect(b.content).to eq ["BLANK NODE COMMENT"]
         expect(b.format.first).to eq "text/plain"
       end
@@ -306,12 +310,12 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
         expect(a.hasTarget.first.rdf_subject.to_s).to eq "http://example.org/bibref/br3"
         expect(a.annotatedBy.first).to eq a_person
         expect(a.annotatedAt.first).to eq a_time
-        expect(a.motivatedBy.first).to eq RDFVocabularies::OA.tagging
+        expect(a.motivatedBy.first).to eq RDF::Vocab::OA.tagging
 
         b = a.getBody
         expect(b).to be_a_kind_of(LD4L::OpenAnnotationRDF::TagBody)
-        expect(b.type).to include RDFVocabularies::OA.Tag
-        expect(b.type).to include RDFVocabularies::CNT.ContentAsText
+        expect(b.type).to include RDF::Vocab::OA.Tag
+        expect(b.type).to include RDF::Vocab::CNT.ContentAsText
         expect(b.tag).to eq ["BLANK_NODE_TAG"]
       end
 
@@ -337,11 +341,11 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
         expect(a.hasTarget.first.rdf_subject.to_s).to eq "http://example.org/bibref/br3"
         expect(a.annotatedBy.first).to eq a_person
         expect(a.annotatedAt.first).to eq a_time
-        expect(a.motivatedBy.first).to eq RDFVocabularies::OA.tagging
+        expect(a.motivatedBy.first).to eq RDF::Vocab::OA.tagging
 
         b = a.getBody
         expect(b).to be_a_kind_of(LD4L::OpenAnnotationRDF::SemanticTagBody)
-        expect(b.type).to include RDFVocabularies::OA.SemanticTag
+        expect(b.type).to include RDF::Vocab::OA.SemanticTag
         expect(b.rdf_subject.to_s).to eq('http://example.org/term/3')
       end
     end
@@ -371,16 +375,17 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
           it "populates LD4L::OpenAnnotationRDF::CommentAnnotation properly" do
             expect(@comment_anno.rdf_subject.to_s).to eq @anno_url
             expect(@comment_anno).to be_a LD4L::OpenAnnotationRDF::CommentAnnotation
-            expect(@comment_anno.type).to include(RDFVocabularies::OA.Annotation)
-            expect(@comment_anno.motivatedBy).to include(RDFVocabularies::OA.commenting)
+            expect(@comment_anno.type).to include(RDF::Vocab::OA.Annotation)
+            expect(@comment_anno.motivatedBy).to include(RDF::Vocab::OA.commenting)
             expect(@comment_anno.hasTarget.first.rdf_subject).to eq RDF::URI.new("http://searchworks.stanford.edu/view/666")
           end
           it "populates Comment bodies properly" do
-            body = @comment_anno.hasBody.first
+            # body = @comment_anno.hasBody.first
+            body = @comment_anno.getBody
             expect(body).to be_a LD4L::OpenAnnotationRDF::CommentBody
             expect(body.content.first).to eq @comment_value
-            expect(body.type).to include(RDFVocabularies::CNT.ContentAsText)
-            expect(body.type).to include(RDFVocabularies::DCTYPES.Text)
+            expect(body.type).to include(RDF::Vocab::CNT.ContentAsText)
+            expect(body.type).to include(RDF::Vocab::DCMIType.Text)
           end
         end
 
@@ -408,17 +413,18 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
           it "populates LD4L::OpenAnnotationRDF::TagAnnotation properly" do
             expect(@tag_anno.rdf_subject.to_s).to eq @anno_url
             expect(@tag_anno).to be_a LD4L::OpenAnnotationRDF::TagAnnotation
-            expect(@tag_anno.type).to include(RDFVocabularies::OA.Annotation)
-            expect(@tag_anno.motivatedBy).to include(RDFVocabularies::OA.tagging)
+            expect(@tag_anno.type).to include(RDF::Vocab::OA.Annotation)
+            expect(@tag_anno.motivatedBy).to include(RDF::Vocab::OA.tagging)
             expect(@tag_anno.hasTarget.first.rdf_subject).to eq RDF::URI.new("http://searchworks.stanford.edu/view/666")
           end
           it "populates Tag bodies properly" do
-            body = @tag_anno.hasBody.first
+            # body = @tag_anno.hasBody.first
+            body = @tag_anno.getBody
             expect(body).to be_a LD4L::OpenAnnotationRDF::TagBody
             expect(body.tag.first).to eq @tag_value
-            expect(body.type).to include(RDFVocabularies::OA.Tag)
-            expect(body.type).to include(RDFVocabularies::CNT.ContentAsText)
-            expect(body.type).to include(RDFVocabularies::DCTYPES.Text)
+            expect(body.type).to include(RDF::Vocab::OA.Tag)
+            expect(body.type).to include(RDF::Vocab::CNT.ContentAsText)
+            expect(body.type).to include(RDF::Vocab::DCMIType.Text)
           end
         end
 
@@ -440,15 +446,16 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
           it "populates LD4L::OpenAnnotationRDF::TagAnnotation properly" do
             expect(@semantic_tag_anno.rdf_subject.to_s).to eq @anno_url
             expect(@semantic_tag_anno).to be_a LD4L::OpenAnnotationRDF::SemanticTagAnnotation
-            expect(@semantic_tag_anno.type).to include(RDFVocabularies::OA.Annotation)
-            expect(@semantic_tag_anno.motivatedBy).to include(RDFVocabularies::OA.tagging)
+            expect(@semantic_tag_anno.type).to include(RDF::Vocab::OA.Annotation)
+            expect(@semantic_tag_anno.motivatedBy).to include(RDF::Vocab::OA.tagging)
             expect(@semantic_tag_anno.hasTarget.first.rdf_subject).to eq RDF::URI.new("http://searchworks.stanford.edu/view/666")
           end
           it "populates Tag bodies properly" do
-            body = @semantic_tag_anno.hasBody.first
+            # body = @semantic_tag_anno.hasBody.first
+            body = @semantic_tag_anno.getBody
             expect(body.rdf_subject.to_s).to eq @term_url
             expect(body).to be_a LD4L::OpenAnnotationRDF::SemanticTagBody
-            expect(body.type).to include(RDFVocabularies::OA.SemanticTag)
+            expect(body.type).to include(RDF::Vocab::OA.SemanticTag)
           end
         end
       end
@@ -476,7 +483,7 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
 
       context "when it is saved" do
         before do
-          subject.motivatedBy = RDFVocabularies::OA.commenting
+          subject.motivatedBy = RDF::Vocab::OA.commenting
           subject.persist!
         end
 
@@ -486,7 +493,7 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
 
         context "and then modified" do
           before do
-            subject.motivatedBy = RDFVocabularies::OA.tagging
+            subject.motivatedBy = RDF::Vocab::OA.tagging
           end
 
           it "should return true" do
@@ -499,7 +506,7 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
           end
 
           it "should reset the motivatedBy" do
-            expect(subject.motivatedBy.first.to_s).to eq RDFVocabularies::OA.commenting.to_s
+            expect(subject.motivatedBy.first.to_s).to eq RDF::Vocab::OA.commenting.to_s
           end
 
           it "should be persisted" do
@@ -521,7 +528,7 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
           # Create inmemory repository
           @repo = RDF::Repository.new
           ActiveTriples::Repositories.repositories[:default] = @repo
-          subject.motivatedBy = RDFVocabularies::OA.commenting
+          subject.motivatedBy = RDF::Vocab::OA.commenting
           result
         end
 
@@ -535,7 +542,7 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
 
         it "should delete from the repository" do
           subject.reload
-          expect(subject.motivatedBy.first.to_s).to eq RDFVocabularies::OA.commenting.to_s
+          expect(subject.motivatedBy.first.to_s).to eq RDF::Vocab::OA.commenting.to_s
           subject.motivatedBy = []
           expect(subject.motivatedBy).to eq []
           subject.persist!
@@ -549,7 +556,7 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
 
   describe '#destroy!' do
     before do
-      subject << RDF::Statement(RDF::DC.LicenseDocument, RDF::DC.title, 'LICENSE')
+      subject << RDF::Statement(RDF::Vocab::DC.LicenseDocument, RDF::Vocab::DC.title, 'LICENSE')
     end
 
     subject { LD4L::OpenAnnotationRDF::Annotation.new('123') }
@@ -615,11 +622,11 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
 
     context 'with unmodeled data' do
       before do
-        subject << RDF::Statement(subject.rdf_subject, RDF::DC.contributor, 'Tove Jansson')
-        subject << RDF::Statement(subject.rdf_subject, RDF::DC.relation, RDF::URI('http://example.org/moomi'))
+        subject << RDF::Statement(subject.rdf_subject, RDF::Vocab::DC.contributor, 'Tove Jansson')
+        subject << RDF::Statement(subject.rdf_subject, RDF::Vocab::DC.relation, RDF::URI('http://example.org/moomi'))
         node = RDF::Node.new
-        subject << RDF::Statement(RDF::URI('http://example.org/moomi'), RDF::DC.relation, node)
-        subject << RDF::Statement(node, RDF::DC.title, 'bnode')
+        subject << RDF::Statement(RDF::URI('http://example.org/moomi'), RDF::Vocab::DC.relation, node)
+        subject << RDF::Statement(node, RDF::Vocab::DC.title, 'bnode')
       end
 
       after do
@@ -628,21 +635,21 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
       end
 
       it 'should include data with URIs as attribute names' do
-        expect(subject.attributes[RDF::DC.contributor.to_s]).to eq ['Tove Jansson']
+        expect(subject.attributes[RDF::Vocab::DC.contributor.to_s]).to eq ['Tove Jansson']
       end
 
       it 'should return generic Resources' do
-        expect(subject.attributes[RDF::DC.relation.to_s].first).to be_a ActiveTriples::Resource
+        expect(subject.attributes[RDF::Vocab::DC.relation.to_s].first).to be_a ActiveTriples::Resource
       end
 
       it 'should build deep data for Resources' do
-        expect(subject.attributes[RDF::DC.relation.to_s].first.get_values(RDF::DC.relation).
-                   first.get_values(RDF::DC.title)).to eq ['bnode']
+        expect(subject.attributes[RDF::Vocab::DC.relation.to_s].first.get_values(RDF::Vocab::DC.relation).
+                   first.get_values(RDF::Vocab::DC.title)).to eq ['bnode']
       end
 
       it 'should include deep data in serializable_hash' do
-        expect(subject.serializable_hash[RDF::DC.relation.to_s].first.get_values(RDF::DC.relation).
-                   first.get_values(RDF::DC.title)).to eq ['bnode']
+        expect(subject.serializable_hash[RDF::Vocab::DC.relation.to_s].first.get_values(RDF::Vocab::DC.relation).
+                   first.get_values(RDF::Vocab::DC.title)).to eq ['bnode']
       end
     end
 
@@ -719,13 +726,13 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
 
   describe 'editing the graph' do
     it 'should write properties when statements are added' do
-      subject << RDF::Statement.new(subject.rdf_subject, RDFVocabularies::OA.motivatedBy, 'commenting')
+      subject << RDF::Statement.new(subject.rdf_subject, RDF::Vocab::OA.motivatedBy, 'commenting')
       expect(subject.motivatedBy).to include 'commenting'
     end
 
     it 'should delete properties when statements are removed' do
-      subject << RDF::Statement.new(subject.rdf_subject, RDFVocabularies::OA.motivatedBy, 'commenting')
-      subject.delete RDF::Statement.new(subject.rdf_subject, RDFVocabularies::OA.motivatedBy, 'commenting')
+      subject << RDF::Statement.new(subject.rdf_subject, RDF::Vocab::OA.motivatedBy, 'commenting')
+      subject.delete RDF::Statement.new(subject.rdf_subject, RDF::Vocab::OA.motivatedBy, 'commenting')
       expect(subject.motivatedBy).to eq []
     end
   end
@@ -734,18 +741,18 @@ describe 'LD4L::OpenAnnotationRDF::Annotation' do
     before do
       class DummyPerson < ActiveTriples::Resource
         configure :type => RDF::URI('http://example.org/Person')
-        property :foafname, :predicate => RDF::FOAF.name
-        property :publications, :predicate => RDF::FOAF.publications, :class_name => 'DummyDocument'
-        property :knows, :predicate => RDF::FOAF.knows, :class_name => DummyPerson
+        property :foafname, :predicate => RDF::Vocab::FOAF.name
+        property :publications, :predicate => RDF::Vocab::FOAF.publications, :class_name => 'DummyDocument'
+        property :knows, :predicate => RDF::Vocab::FOAF.knows, :class_name => DummyPerson
       end
 
       class DummyDocument < ActiveTriples::Resource
         configure :type => RDF::URI('http://example.org/Document')
-        property :title, :predicate => RDF::DC.title
-        property :creator, :predicate => RDF::DC.creator, :class_name => 'DummyPerson'
+        property :title, :predicate => RDF::Vocab::DC.title
+        property :creator, :predicate => RDF::Vocab::DC.creator, :class_name => 'DummyPerson'
       end
 
-      LD4L::OpenAnnotationRDF::Annotation.property :item, :predicate => RDF::DC.relation, :class_name => DummyDocument
+      LD4L::OpenAnnotationRDF::Annotation.property :item, :predicate => RDF::Vocab::DC.relation, :class_name => DummyDocument
     end
 
     subject { LD4L::OpenAnnotationRDF::Annotation.new }
@@ -800,8 +807,10 @@ END
       document1.creator = [person1, person2]
       document2.creator = person1
       person1.knows = person2
+      person2.knows = person1
       subject.item = [document1]
-      expect(subject.item.first.creator.first.knows.first.foafname).to eq ['Bob']
+      expect(subject.item.first.creator.first.knows.first.foafname)
+          .to satisfy { |names| ['Alice', 'Bob'].include? names.first }
     end
   end
 end