triannon 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d20d2124fb17c180ab12ea7b7327231153911b78
-  data.tar.gz: 983a6a576832035c3fdc880c6f238543330abd9e
+  metadata.gz: f3fb1a2a5664cb23544e3809666e40fbeac50bf7
+  data.tar.gz: 530b85774e11c73ad4ace71448e200babf0e2887
 SHA512:
-  metadata.gz: fa243bfb9936f35133da5a99f863698415fcbeb9c05ebe924b4af6250579351ed719b4c3b6a23dcd2de94a9017b1721455fef48527630abbd7d95b54aff32c6b
-  data.tar.gz: 7343b0510476dde7a96efad33f16b2d3d771361edd2c4155be3342911c40da2e154ce38d5de0a944400e4c30ccf48221ed7477e407a77fb7e3c66161775f3e49
+  metadata.gz: d053edac7a6da6482140dc9c9eb4fda5ea467f772b1cc94a5fc05f0b866e2b2575d81278db451d6101b4856fa9ed4974b9677df28f26801f7483f7be375cba95
+  data.tar.gz: 88807450e57ec3e5a801b8be3480dee4c4b7f5d2b46401e0abb0cbfdcbcdfa21306933d1d6b0aa521d251602f86df55bb6545e3ed8a9f81bc76323dd2e20d90d

data/README.md

@@ -24,21 +24,24 @@ $ rails g triannon:install
 
 Edit the `config/triannon.yml` file:
 
-* `ldp_url:` Points to the root annotations container on your LDP server
+* `ldp:` Properties of LDP server
+  * `url:` the baseurl of LDP server
+  * `uber_container:` name of an LDP Basic Container holding specific anno containers
+  * `anno_containers:`  (Future: the names of LDP Basic Containers holding individual annos)
 * `solr_url:` Points to the baseurl of Solr instance configured for Triannon
 * `triannon_base_url:` Used as the base url for all annotations hosted by your Triannon server.  Identifiers from the LDP server will be appended to this base-url.  Generally something like "https://your-triannon-rails-box/annotations", as "/annotations" is added to the path by the Triannon gem
 
-Generate the root annotations container on your LDP server:
+Generate the uber root annotations container on your LDP server:
 
 ```console
-$ rake triannon:create_root_container
+$ rake triannon:create_uber_root_container
 ```
 
 Set up caching for jsonld context documents:
 
 * by using Rack::Cache for RestClient:
 
-** add to Gemfile:
+  * add to Gemfile:
 
 ```ruby
 gem 'rest-client'
@@ -46,8 +49,9 @@ gem 'rack-cache'
 gem 'rest-client-components'
 ```
 
-*** bundle install
-** create a  config/initializers/rest_client.rb
+    * bundle install
+
+  * create a  config/initializers/rest_client.rb
 
 ```ruby
 require 'restclient/components'
@@ -143,12 +147,13 @@ There is a bundled rake task for running triannon in a test rails application, b
 ```console
 $ rake jetty:download
 $ rake jetty:unzip
+$ rake jetty:environment
+$ rake triannon:jetty_setup
 ```
 
-### Set up a Triannon flavored Solr
-```console
-rake triannon:solr_jetty_setup
-```
+triannon:jetty_setup task does the following:
+* turns off basic authorization in Fedora4
+* sets up a Triannon flavored Solr
 
 ### Set up the testing Rails app that uses triannon gem
 ```console
@@ -171,14 +176,14 @@ well, try:
 
 ```console
 $ rake jetty:stop
-$ rake triannon:solr_jetty_setup
+$ rake triannon:jetty_setup
 $ rake jetty:start
 ```
 
 and then check again.
 
 
-#### Check if Fedora is up
+#### Check if Fedora4 is up
 Go to http://localhost:8983/fedora/rest/
 
 If all is well, you will not get an error message.  If all is not well, try:
@@ -186,23 +191,23 @@ If all is well, you will not get an error message.  If all is not well, try:
 ```console
 $ rake jetty:stop
 $ rake jetty:clean
-$ rake triannon:solr_jetty_startup
+$ rake triannon:jetty_startup
 $ rake jetty:start
 ```
 
 and check for Solr and Fedora again.
 
-#### Generate root annotations container
+#### Generate uber root annotations container
 After you ensure that Fedora4 is running:
 
 ```console
 $ cd spec/internal
-$ rake triannon:create_root_container
+$ rake triannon:create_uber_root_container
 $ cd ../..
 ```
 
 #### Configure spec/internal/config/triannon.yml as specified above
-You might not need to change the file.
+You probably won't need to change this file.
 ```console
 $ vi spec/internal/config/triannon.yml
 ```

data/Rakefile

@@ -4,7 +4,7 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-ZIP_URL = "https://github.com/sul-dlss/hydra-jetty/archive/fedora-4/edge.zip"
+ZIP_URL = "https://github.com/projecthydra/hydra-jetty/archive/v8.3.1.zip"
 
 require 'active_support/benchmarkable'
 require 'jettywrapper'
@@ -16,6 +16,17 @@ task :ci => 'engine_cart:generate' do
   Rake::Task['spec'].invoke
 end
 
+load 'rails/tasks/statistics.rake'
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :ci
+
+
+Dir.glob('lib/tasks/*.rake').each { |r| load r}
+
 namespace :triannon do
   desc 'run test rails app w triannon and jetty'
   task :server_jetty do
@@ -55,22 +66,7 @@ namespace :triannon do
   desc 'run test rails console w triannon but no jetty'
   task :console => :console_no_jetty
 
-
-  desc "set up triannon solr in test jetty"
-  task :solr_jetty_setup do
-    `cp -r config/solr/triannon-core jetty/solr`
-    `cp config/solr/solr.xml jetty/solr`
-  end
-end
-
-
-load 'rails/tasks/statistics.rake'
-
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :ci
+end # namespace triannon
 
 
 desc "Generate RDoc with YARD"
@@ -98,7 +94,8 @@ namespace :doc do
 
   desc "Remove generated documenation"
   task :clean do
-    rm_r 'rdoc' if File.exists?('rdoc')
+    rm_r 'rdoc' if File.exist?('rdoc')
   end
 end
+
 Bundler::GemHelper.install_tasks

data/app/controllers/concerns/rdf_response_formats.rb

@@ -24,9 +24,11 @@ module RdfResponseFormats
     end
   end
 
-  # parse the Accept HTTP header for the value of profile if it is a request for jsonld or json
-  # e.g. Accept: application/ld+json; profile="http://www.w3.org/ns/oa-context-20130208.json"
-  # @return [String] url for jsonld @context or nil if missing or non-jsonld/json format
+  # parse the Accept HTTP header for the value of profile if it is a request for
+  #   jsonld or json.
+  #  e.g. Accept: application/ld+json; profile="http://www.w3.org/ns/oa-context-20130208.json"
+  # @return [String] url for jsonld @context or nil if missing or
+  #   non-jsonld/json format
   def context_url_from_accept
     if request.format == "jsonld" || request.format == "json"
       accept_str = request.accept
@@ -35,9 +37,9 @@ module RdfResponseFormats
         context_url = context_url[1, context_url.size] if context_url.start_with?('"')
         context_url = context_url[0, context_url.size-1] if context_url.end_with?('"')
         case context_url
-          when Triannon::JsonldContext::OA_DATED_CONTEXT_URL,
-            Triannon::JsonldContext::OA_CONTEXT_URL,
-            Triannon::JsonldContext::IIIF_CONTEXT_URL
+          when OA::Graph::OA_DATED_CONTEXT_URL,
+            OA::Graph::OA_CONTEXT_URL,
+            OA::Graph::IIIF_CONTEXT_URL
             context_url
           else
             nil
@@ -46,19 +48,21 @@ module RdfResponseFormats
     end
   end
 
-  # parse the Accept HTTP Link for the value of rel if it is a request for jsonld or json
+  # parse the Accept HTTP Link for the value of rel if it is a request for
+  #   jsonld or json
   # e.g. Link: http://www.w3.org/ns/oa.json; rel="http://www.w3.org/ns/json-ld#context"; type="application/ld+json"
   # note that the "type" part is optional
-  # @return [String] url for jsonld @context or nil if missing or non-jsonld/json format
+  # @return [String] url for jsonld @context or nil if missing or
+  #   non-jsonld/json format
   def context_url_from_link
     if request.format == "jsonld" || request.format == "json"
       link_str = request.headers["Link"]
       if link_str && link_str.split("; rel=") && link_str.split("; rel=").first
         context_url = link_str.split("; rel=").first.strip
         case context_url
-          when Triannon::JsonldContext::OA_DATED_CONTEXT_URL,
-            Triannon::JsonldContext::OA_CONTEXT_URL,
-            Triannon::JsonldContext::IIIF_CONTEXT_URL
+          when OA::Graph::OA_DATED_CONTEXT_URL,
+            OA::Graph::OA_CONTEXT_URL,
+            OA::Graph::IIIF_CONTEXT_URL
             context_url
           else
             nil
@@ -67,6 +71,4 @@ module RdfResponseFormats
     end
   end
 
-
-
-end
+end

data/app/controllers/triannon/annotations_controller.rb

@@ -17,11 +17,11 @@ module Triannon
 
     # GET /annotations/1
     def show
-      # TODO:  json.set! "@context", Triannon::JsonldContext::OA_DATED_CONTEXT_URL - would this work?
+      # TODO:  json.set! "@context", OA::Graph::OA_DATED_CONTEXT_URL - would this work?
       respond_to do |format|
         format.jsonld {
           context_url = context_url_from_accept ? context_url_from_accept : context_url_from_link
-          if context_url && context_url == Triannon::JsonldContext::IIIF_CONTEXT_URL
+          if context_url && context_url == OA::Graph::IIIF_CONTEXT_URL
             render_jsonld_per_context("iiif", "application/ld+json")
           else
             render_jsonld_per_context(params[:jsonld_context], "application/ld+json")
@@ -36,7 +36,7 @@ module Triannon
         format.json {
           accept_return_type = mime_type_from_accept(["application/json", "text/x-json", "application/jsonrequest"])
           context_url = context_url_from_link ? context_url_from_link : context_url_from_accept
-          if context_url && context_url == Triannon::JsonldContext::IIIF_CONTEXT_URL
+          if context_url && context_url == OA::Graph::IIIF_CONTEXT_URL
             render_jsonld_per_context("iiif", accept_return_type)
           else
             render_jsonld_per_context(params[:jsonld_context], accept_return_type)
@@ -82,7 +82,7 @@ module Triannon
         respond_to do |format|
           format.jsonld {
             context_url = context_url_from_link ? context_url_from_link : context_url_from_accept
-            if context_url && context_url == Triannon::JsonldContext::IIIF_CONTEXT_URL
+            if context_url && context_url == OA::Graph::IIIF_CONTEXT_URL
               render :json => @annotation.jsonld_iiif, status: 201, content_type: "application/ld+json"
             else
               render :json => @annotation.jsonld_oa, status: 201, content_type: "application/ld+json"
@@ -97,7 +97,7 @@ module Triannon
           format.json {
             accept_return_type = mime_type_from_accept(["application/json", "text/x-json", "application/jsonrequest"])
             context_url = context_url_from_link ? context_url_from_link : context_url_from_accept
-            if context_url && context_url == Triannon::JsonldContext::IIIF_CONTEXT_URL
+            if context_url && context_url == OA::Graph::IIIF_CONTEXT_URL
               render :json => @annotation.jsonld_iiif, status: 201, content_type: accept_return_type if accept_return_type
             else
               render :json => @annotation.jsonld_oa, status: 201, content_type: accept_return_type if accept_return_type
@@ -155,7 +155,7 @@ private
     # render json_ld respecting requested context
     # @param [String] req_context set to "iiif" or "oa".  Default is oa
     # @param [String] mime_type the mime type to be set in the Content-Type header of the HTTP response
-    def render_jsonld_per_context (req_context, mime_type=nil)
+    def render_jsonld_per_context(req_context, mime_type = nil)
       case req_context
         when "iiif", "IIIF"
           if mime_type

data/app/models/triannon/annotation.rb

@@ -60,22 +60,22 @@ module Triannon
     end
 
     def persisted?
-      self.id.present?
+      id.present?
     end
 
     def graph
       @graph ||= begin
         g = data_to_graph
-        Triannon::Graph.new g if g.kind_of? RDF::Graph
+        OA::Graph.new g if g.kind_of? RDF::Graph
       end
     end
 
-    # @param g either a Triannon::Graph or RDF::Graph object
+    # @param g either a OA::Graph or RDF::Graph object
     def graph= g
-      if g.is_a? Triannon::Graph
+      if g.is_a? OA::Graph
         @graph = g
       elsif g.kind_of? RDF::Graph
-        @graph = Triannon::Graph.new g
+        @graph = OA::Graph.new g
       end
     end
 

data/app/models/triannon/annotation_ldp.rb

@@ -1,6 +1,6 @@
 module Triannon
-  # an LDP aware model of an Annotation -- basically, a shim between the OA notion of an annotation 
-  #  and the LDP storage.
+  # an LDP aware model of an Annotation -- basically, a shim between the OA
+  #  notion of an annotation and the LDP storage.
   class AnnotationLdp
 
     # RDF::Graph object with all triples, including back end (e.g. LDP, Fedora)
@@ -10,43 +10,44 @@ module Triannon
 
     # RDF::Graph without any back end (e.g. LDP, Fedora) triples
     def stripped_graph
-      RDF::LDP.remove_ldp_triples (RDF::FCRepo4.remove_fedora_triples(graph))
+      OA::Graph.remove_ldp_triples(OA::Graph.remove_fedora_triples(graph))
     end
 
     def base_uri
-      res = graph.query Triannon::Graph.anno_query
+      res = graph.query OA::Graph.anno_query
       res.first.s
     end
 
     # @return [Array<String>] the uris of each LDP body resource
     def body_uris
-      q = Triannon::Graph.anno_query.dup
-      q << [:s, RDF::OpenAnnotation.hasBody, :body_uri]
+      q = OA::Graph.anno_query.dup
+      q << [:s, RDF::Vocab::OA.hasBody, :body_uri]
       solns = graph.query q
       result = []
-      solns.distinct.each { |soln| 
-        result << soln.body_uri 
+      solns.distinct.each { |soln|
+        result << soln.body_uri
       }
       result
     end
 
     # @return [Array<String>] the uris of each LDP target resource
     def target_uris
-      q = Triannon::Graph.anno_query.dup
-      q << [:s, RDF::OpenAnnotation.hasTarget, :target_uri]
+      q = OA::Graph.anno_query.dup
+      q << [:s, RDF::Vocab::OA.hasTarget, :target_uri]
       solns = graph.query q
       result = []
-      solns.distinct.each { |soln| 
-        result << soln.target_uri 
+      solns.distinct.each { |soln|
+        result << soln.target_uri
       }
       result
     end
-    
+
     # add the passed statements to #graph
-    # @param [Array<RDF::Statement>] statements an array of RDF statements to be loaded into the graph
-    def load_statements_into_graph statements
+    # @param [Array<RDF::Statement>] statements an array of RDF statements to be
+    #   loaded into the graph
+    def load_statements_into_graph(statements)
       graph.insert(statements) if statements && statements.size > 0
     end
 
   end
-end
+end

data/app/services/triannon/ldp_loader.rb

@@ -27,8 +27,17 @@ module Triannon
     # @param [String] id the unique id of the annotation.  Can include base_uri prefix or omit it.
     def initialize id = nil
       @id = id
-      @base_uri = Triannon.config[:ldp_url]
+      base_url = Triannon.config[:ldp]['url']
+      base_url.chop! if base_url.end_with?('/')
+      container_path = Triannon.config[:ldp]['uber_container']
+      if container_path
+        container_path.strip!
+        container_path = container_path[1..-1] if container_path.start_with?('/')
+        container_path.chop! if container_path.end_with?('/')
+      end
+      @base_uri = "#{base_url}/#{container_path}"
       @ldp_annotation = Triannon::AnnotationLdp.new
+
     end
 
     # load annotation container object into @ldp_annotation's (our Triannon::AnnotationLdp object) graph
@@ -61,8 +70,9 @@ module Triannon
       g = RDF::Graph.new
       g.from_ttl root_ttl
       root_uri = RDF::URI.new @base_uri
-      results = g.query [root_uri, RDF::LDP.contains, nil]
+      results = g.query [root_uri, RDF::Vocab::LDP.contains, nil]
       results.each do |stmt|
+        # FIXME:  can't be last with pair trees in fedora urls - leave broke as this method is deprecated
         id = stmt.object.to_s.split('/').last
         objs << Triannon::Annotation.new(:id => id)
       end
@@ -86,7 +96,7 @@ module Triannon
         req.headers['Accept'] = 'application/x-turtle'
       end
       if resp.status.between?(400, 600)
-        raise Triannon::LDPStorageError.new("error getting #{sub_path} from LDP", resp.status, resp.body)
+        fail Triannon::LDPStorageError.new("error getting #{sub_path} from LDP", resp.status, resp.body)
       else
         resp.body
       end
@@ -99,7 +109,7 @@ module Triannon
     def statements_from_ttl_minus_fedora ttl
       # RDF::Turtle::Reader.new(ttl).statements.to_a
       g = RDF::Graph.new.from_ttl(ttl) if ttl
-      RDF::FCRepo4.remove_fedora_triples(g).statements if g
+      OA::Graph.remove_fedora_triples(g).statements if g
     end
 
     def conn

data/app/services/triannon/ldp_to_oa_mapper.rb

@@ -16,25 +16,34 @@ module Triannon
       @ldp_anno = ldp_anno
       @ldp_anno_graph = ldp_anno.stripped_graph
       g = RDF::Graph.new
-      @oa_graph = Triannon::Graph.new g
+      @oa_graph = OA::Graph.new g
     end
 
     def extract_base
-      root_subject_solns = @ldp_anno_graph.query Triannon::Graph.anno_query
+      root_subject_solns = @ldp_anno_graph.query OA::Graph.anno_query
       if root_subject_solns.count == 1
-        @id = root_subject_solns[0].s.to_s.split('/').last
+        stored_url = Triannon.config[:ldp]['url'].strip
+        stored_url.chop! if stored_url.end_with?('/')
+        container_path = Triannon.config[:ldp]['uber_container']
+        if container_path
+          container_path.strip!
+          container_path = container_path[1..-1] if container_path.start_with?('/')
+          container_path.chop! if container_path.end_with?('/')
+          stored_url = "#{stored_url}/#{container_path}"
+        end
+        @id = root_subject_solns[0].s.to_s.split("#{stored_url}/").last
         base_url = Triannon.config[:triannon_base_url]
         base_url.strip!
         base_url.chop! if base_url[-1] == '/'
         @root_uri = RDF::URI.new(base_url + "/#{@id}")
       end
-      
+
       @ldp_anno_graph.each_statement do |stmnt|
-        if stmnt.predicate == RDF.type && stmnt.object == RDF::OpenAnnotation.Annotation
-          @oa_graph << [@root_uri, RDF.type, RDF::OpenAnnotation.Annotation]
-        elsif stmnt.predicate == RDF::OpenAnnotation.motivatedBy
+        if stmnt.predicate == RDF.type && stmnt.object == RDF::Vocab::OA.Annotation
+          @oa_graph << [@root_uri, RDF.type, RDF::Vocab::OA.Annotation]
+        elsif stmnt.predicate == RDF::Vocab::OA.motivatedBy
           @oa_graph << [@root_uri, stmnt.predicate, stmnt.object]
-        elsif stmnt.predicate == RDF::OpenAnnotation.annotatedAt
+        elsif stmnt.predicate == RDF::Vocab::OA.annotatedAt
           @oa_graph << [@root_uri, stmnt.predicate, stmnt.object]
         end
       end
@@ -42,28 +51,28 @@ module Triannon
 
     def extract_bodies
       @ldp_anno.body_uris.each { |body_uri|
-        if !map_external_ref(body_uri, RDF::OpenAnnotation.hasBody) &&
-            !map_content_as_text(body_uri, RDF::OpenAnnotation.hasBody) &&
-            !map_specific_resource(body_uri, RDF::OpenAnnotation.hasBody)
-          map_choice(body_uri, RDF::OpenAnnotation.hasBody)
+        if !map_external_ref(body_uri, RDF::Vocab::OA.hasBody) &&
+            !map_content_as_text(body_uri, RDF::Vocab::OA.hasBody) &&
+            !map_specific_resource(body_uri, RDF::Vocab::OA.hasBody)
+          map_choice(body_uri, RDF::Vocab::OA.hasBody)
         end
       }
     end
 
     def extract_targets
-      @ldp_anno.target_uris.each { |target_uri| 
-        if !map_external_ref(target_uri, RDF::OpenAnnotation.hasTarget) &&
-            !map_specific_resource(target_uri, RDF::OpenAnnotation.hasTarget)
-          map_choice(target_uri, RDF::OpenAnnotation.hasTarget)
+      @ldp_anno.target_uris.each { |target_uri|
+        if !map_external_ref(target_uri, RDF::Vocab::OA.hasTarget) &&
+            !map_specific_resource(target_uri, RDF::Vocab::OA.hasTarget)
+          map_choice(target_uri, RDF::Vocab::OA.hasTarget)
         end
       }
     end
-    
+
     # if uri_obj is the subject of a Triannon.externalReference then add appropriate
     #  statements to @oa_graph and return true
     # @param [RDF::URI] uri_obj the object that may have RDF::Triannon.externalReference
     # @param [RDF::URI] predicate the predicate for [subject_obj, predicate, (ext_url)] statement
-    # to be added to @oa_graph, e.g. RDF::OpenAnnotation.hasTarget
+    # to be added to @oa_graph, e.g. RDF::Vocab::OA.hasTarget
     # @param [RDF::URI] subject_obj the subject object to get the predicate statement; defaults to @root_uri
     # @return [Boolean] true if it adds statements to @oa_graph, false otherwise
     def map_external_ref uri_obj, predicate, subject_obj = @root_uri
@@ -71,8 +80,8 @@ module Triannon
       if solns.count > 0
         external_uri = solns.first.object
         @oa_graph << [subject_obj, predicate, external_uri]
-        
-        Triannon::Graph.subject_statements(uri_obj, @ldp_anno_graph).each { |stmt|
+
+        OA::Graph.subject_statements(uri_obj, @ldp_anno_graph).each { |stmt|
           if stmt.subject == uri_obj && stmt.predicate != RDF::Triannon.externalReference
             @oa_graph << [external_uri, stmt.predicate, stmt.object]
           else
@@ -84,21 +93,21 @@ module Triannon
         false
       end
     end
-    
-    # if uri_obj has a type of RDF::Content.ContentAsText, then this is a skolemized blank node;
+
+    # if uri_obj has a type of RDF::Vocab::CNT.ContentAsText, then this is a skolemized blank node;
     #  add appropriate statements to @oa_graph to represent the blank node and its contents and return true
-    # @param [RDF::URI] uri_obj the object that may type RDF::Content.ContentAsText
+    # @param [RDF::URI] uri_obj the object that may type RDF::Vocab::CNT.ContentAsText
     # @param [RDF::URI] predicate the predicate for [subject_obj, predicate, (ext_url)] statement
-    # to be added to @oa_graph, e.g. RDF::OpenAnnotation.hasTarget
+    # to be added to @oa_graph, e.g. RDF::Vocab::OA.hasTarget
     # @param [RDF::URI] subject_obj the subject object to get the predicate statement; defaults to @root_uri
     # @return [Boolean] true if it adds statements to @oa_graph, false otherwise
     def map_content_as_text uri_obj, predicate, subject_obj = @root_uri
-      solns = @ldp_anno_graph.query [uri_obj, RDF.type, RDF::Content.ContentAsText]
+      solns = @ldp_anno_graph.query [uri_obj, RDF.type, RDF::Vocab::CNT.ContentAsText]
       if solns.count > 0
         blank_node = RDF::Node.new
         @oa_graph << [subject_obj, predicate, blank_node]
-        
-        Triannon::Graph.subject_statements(uri_obj, @ldp_anno_graph).each { |stmt|
+
+        OA::Graph.subject_statements(uri_obj, @ldp_anno_graph).each { |stmt|
           if stmt.subject == uri_obj
             @oa_graph << [blank_node, stmt.predicate, stmt.object]
           else
@@ -111,45 +120,45 @@ module Triannon
         false
       end
     end
-    
-    # if uri_obj has a type of RDF::OpenAnnotation.SpecificResource, then this is a skolemized blank node;
+
+    # if uri_obj has a type of RDF::Vocab::OA.SpecificResource, then this is a skolemized blank node;
     #  add appropriate statements to @oa_graph to represent the blank node and its contents and return true
-    # @param [RDF::URI] uri_obj the object that may have type RDF::OpenAnnotation.SpecificResource
+    # @param [RDF::URI] uri_obj the object that may have type RDF::Vocab::OA.SpecificResource
     # @param [RDF::URI] predicate the predicate for [@root_uri, predicate, (sel_res)] statement
-    # to be added to @oa_graph, e.g. RDF::OpenAnnotation.hasTarget
+    # to be added to @oa_graph, e.g. RDF::Vocab::OA.hasTarget
     # @return [Boolean] true if it adds statements to @oa_graph, false otherwise
     def map_specific_resource uri_obj, predicate
-      solns = @ldp_anno_graph.query [uri_obj, RDF.type, RDF::OpenAnnotation.SpecificResource]
+      solns = @ldp_anno_graph.query [uri_obj, RDF.type, RDF::Vocab::OA.SpecificResource]
       if solns.count > 0
         blank_node = RDF::Node.new
         @oa_graph << [@root_uri, predicate, blank_node]
-        
+
         source_obj = nil
         selector_obj = nil
         selector_blank_node = nil
-        specific_res_stmts = Triannon::Graph.subject_statements(uri_obj, @ldp_anno_graph)
+        specific_res_stmts = OA::Graph.subject_statements(uri_obj, @ldp_anno_graph)
         specific_res_stmts.each { |stmt|
-          if stmt.predicate == RDF::OpenAnnotation.hasSource
+          if stmt.predicate == RDF::Vocab::OA.hasSource
             # expecting a hash URI
             source_obj = stmt.object
-            if source_obj.to_s.match("#{uri_obj.to_s}#source")
-              source_has_ext_uri = map_external_ref source_obj, RDF::OpenAnnotation.hasSource, blank_node
+            if source_obj.to_s.match("#{uri_obj}#source")
+              source_has_ext_uri = map_external_ref source_obj, RDF::Vocab::OA.hasSource, blank_node
             end
-          elsif stmt.predicate == RDF::OpenAnnotation.hasSelector
+          elsif stmt.predicate == RDF::Vocab::OA.hasSelector
             # this becomes a blank node.  Per http://www.openannotation.org/spec/core/specific.html#Selectors
             # "Typically if all of the information needed to resolve the Selector (or other Specifier)
-            #  is present within the graph, such as is the case for the 
-            # FragmentSelector, TextQuoteSelector, TextPositionSelector and DataPositionSelector classes, 
+            #  is present within the graph, such as is the case for the
+            # FragmentSelector, TextQuoteSelector, TextPositionSelector and DataPositionSelector classes,
             # then there is no need to have a resolvable resource that provides the same information."
             selector_obj = stmt.object
             selector_blank_node = RDF::Node.new
-            @oa_graph << [blank_node, RDF::OpenAnnotation.hasSelector, selector_blank_node]
+            @oa_graph << [blank_node, RDF::Vocab::OA.hasSelector, selector_blank_node]
           end
         }
-        
-        # We can't know we'll hit hasSource and hasSelector statements in graph first, 
+
+        # We can't know we'll hit hasSource and hasSelector statements in graph first,
         # so we must do another pass through the statements to get that information
-        specific_res_stmts.each { |stmt| 
+        specific_res_stmts.each { |stmt|
           if stmt.subject == uri_obj && stmt.object != source_obj && stmt.object != selector_obj
             @oa_graph << [blank_node, stmt.predicate, stmt.object]
           elsif stmt.subject != source_obj
@@ -165,40 +174,40 @@ module Triannon
       end
     end
 
-    # if uri_obj has a type of RDF::OpenAnnotation.Choice, then this is a skolemized blank node;
+    # if uri_obj has a type of RDF::Vocab::OA.Choice, then this is a skolemized blank node;
     #  add appropriate statements to @oa_graph to represent the blank node and its contents and return true
-    # @param [RDF::URI] uri_obj the object that may have type RDF::OpenAnnotation.Choice
+    # @param [RDF::URI] uri_obj the object that may have type RDF::Vocab::OA.Choice
     # @param [RDF::URI] predicate the predicate for [@root_uri, predicate, (choice)] statement
-    # to be added to @oa_graph, e.g. RDF::OpenAnnotation.hasTarget
+    # to be added to @oa_graph, e.g. RDF::Vocab::OA.hasTarget
     # @return [Boolean] true if it adds statements to @oa_graph, false otherwise
     def map_choice uri_obj, predicate
-      solns = @ldp_anno_graph.query [uri_obj, RDF.type, RDF::OpenAnnotation.Choice]
+      solns = @ldp_anno_graph.query [uri_obj, RDF.type, RDF::Vocab::OA.Choice]
       if solns.count > 0
         blank_node = RDF::Node.new
         @oa_graph << [@root_uri, predicate, blank_node]
-        
+
         default_obj = nil
         item_objs = []
-        choice_stmts = Triannon::Graph.subject_statements(uri_obj, @ldp_anno_graph)
+        choice_stmts = OA::Graph.subject_statements(uri_obj, @ldp_anno_graph)
         choice_stmts.each { |stmt|
-          if stmt.predicate == RDF::OpenAnnotation.default
+          if stmt.predicate == RDF::Vocab::OA.default
             default_obj = stmt.object
             # assume it is either ContentAsText or external ref
-            if !map_content_as_text(default_obj, RDF::OpenAnnotation.default, blank_node)
-              map_external_ref(default_obj, RDF::OpenAnnotation.default, blank_node)
+            if !map_content_as_text(default_obj, RDF::Vocab::OA.default, blank_node)
+              map_external_ref(default_obj, RDF::Vocab::OA.default, blank_node)
             end
-          elsif stmt.predicate == RDF::OpenAnnotation.item
+          elsif stmt.predicate == RDF::Vocab::OA.item
             item_objs << stmt.object
             # assume it is either ContentAsText or external ref
-            if !map_content_as_text(stmt.object, RDF::OpenAnnotation.item, blank_node)
-              map_external_ref(stmt.object, RDF::OpenAnnotation.item, blank_node)
+            if !map_content_as_text(stmt.object, RDF::Vocab::OA.item, blank_node)
+              map_external_ref(stmt.object, RDF::Vocab::OA.item, blank_node)
             end
           end
         }
-        
-        # We can't know we'll hit item and default statements in graph first, 
+
+        # We can't know we'll hit item and default statements in graph first,
         # so we must do another pass through the statements to get that information
-        choice_stmts.each { |stmt| 
+        choice_stmts.each { |stmt|
           if stmt.subject == uri_obj && stmt.object != default_obj && !item_objs.include?(stmt.object)
             @oa_graph << [blank_node, stmt.predicate, stmt.object]
           # there shouldn't be any other unmapped statements present