triannon 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2102031aa5a20dc77e3ba1956520a2f48f1d2753
-  data.tar.gz: c99336415b461a6acec866a6555da19ef00b0c44
+  metadata.gz: f2328d724cb403823e2e7e9fbf5565a1244c1453
+  data.tar.gz: 2424be58316b9d29eb4f8e48eee1ea1914a9b07c
 SHA512:
-  metadata.gz: 804d9258559bab83616b0d68e5b73d1404ff052eee62daeee17d1095a1bbd839c30972daabcb87e77834fbd3e6dd96b8913890936ea47793c3960c52b78fe8da
-  data.tar.gz: 1a1e9f0aa7e61938cce576c854c6c23939d6753d60e3d35147d3e3f7800160043cec7fddf0381637782df1ca86cf823b44d4f1001386a5f1b10c24c2d403ecbe
+  metadata.gz: 7de9938713c92a1c0e654ee71f44bfe558429e7ab2907a8a89752c12520e22e7bece73db6a54106f70e944075b346eb66fefe19c7317f4d7c60198cb6f5ce1a6
+  data.tar.gz: dd44726e702079259c81c29ad89c19e8f9597e0a9493a44041e4021fbba90b4bd9c0901fbfdb57efc4907726472b01fdb802126d1420eaabcbf2ff6d002c6bac

data/README.md

@@ -35,7 +35,7 @@ $ rails g triannon:install
 Edit the `config/triannon.yml` file:
 
 * `ldp_url:` Points to the root annotations container on your LDP server
-* `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.
+* `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 the LDP server
 

data/app/controllers/triannon/annotations_controller.rb

@@ -6,12 +6,12 @@ module Triannon
     before_action :set_annotation, only: [:show, :edit, :update, :destroy]
     rescue_from Triannon::ExternalReferenceError, with: :ext_ref_error
 
-    # GET /annotations/annotations
+    # GET /annotations
     def index
       @annotations = Annotation.all
     end
 
-    # GET /annotations/annotations/1
+    # GET /annotations/1
     def show
       respond_to do |format|
         format.jsonld { render_jsonld_per_context (params[:jsonld_context]) }
@@ -31,17 +31,17 @@ module Triannon
       end
     end
 
-    # GET /annotations/annotations/new
+    # GET /annotations/new
     def new
       @annotation = Annotation.new
     end
 
     # NOT YET IMPLEMENTED
-    # GET /annotations/annotations/1/edit    
+    # GET /annotations/1/edit    
 #    def edit
 #    end
 
-    # POST /annotations/annotations
+    # POST /annotations
     def create
       # FIXME: this is probably a bad way of allowing app form to be used as well as direct post requests
       if params["annotation"]
@@ -63,7 +63,7 @@ module Triannon
     end
 
     # NOT YET IMPLEMENTED
-    # PATCH/PUT /annotations/annotations/1
+    # PATCH/PUT /annotations/1
 #    def update
 #      if @annotation.update(params)
 #        redirect_to @annotation, notice: 'Annotation was successfully updated.'
@@ -72,7 +72,7 @@ module Triannon
 #      end
 #    end
 
-    # DELETE /annotations/annotations/1
+    # DELETE /annotations/1
     def destroy
       @annotation.destroy
       redirect_to annotations_url, status: 204, notice: 'Annotation was successfully destroyed.'

data/app/models/triannon/annotation.rb

@@ -1,6 +1,10 @@
 module Triannon
   class Annotation
     include ActiveModel::Model
+    
+    define_model_callbacks :save, :destroy
+    after_save :solr_save
+    after_destroy :solr_delete
 
     attr_accessor :id, :data
 
@@ -14,13 +18,75 @@ module Triannon
     #   https://github.com/uq-eresearch/lorestore/blob/3e9aa1c69aafd3692c69aa39c64bfdc32b757892/src/main/resources/OAConstraintsSPARQL.json
 
 
+    # Class Methods ----------------------------------------------------------------
+  
+    def self.create(attrs = {})
+      a = Triannon::Annotation.new attrs
+      a.save
+      a
+    end
+
+    def self.find(key)
+      oa_graph = Triannon::LdpLoader.load key
+      anno = Triannon::Annotation.new
+      anno.graph = oa_graph
+      anno.id = key
+      anno
+    end
+
+    def self.all
+      Triannon::LdpLoader.find_all
+    end
+
+    # Instance Methods ----------------------------------------------------------------
+
+    def save
+      _run_save_callbacks do
+        # check if valid?
+        graph
+        @id = Triannon::LdpWriter.create_anno self
+      end
+    end
+
+    def destroy
+      _run_destroy_callbacks do
+        Triannon::LdpWriter.delete_anno @id
+      end
+    end
+
     def persisted?
       self.id.present?
     end
 
+    def graph
+      @graph ||= data_to_graph
+    end
+
+    def graph= g
+      @graph = g
+    end
+    
+    # @return json-ld representation of graph with OpenAnnotation context as a url
+    def jsonld_oa
+      inline_context = graph.dump(:jsonld, :context => Triannon::JsonldContext::OA_CONTEXT_URL)
+      hash_from_json = JSON.parse(inline_context)
+      hash_from_json["@context"] = Triannon::JsonldContext::OA_CONTEXT_URL
+      hash_from_json.to_json
+    end
+    
+    # @return json-ld representation of graph with IIIF context as a url
+    def jsonld_iiif
+      inline_context = graph.dump(:jsonld, :context => Triannon::JsonldContext::IIIF_CONTEXT_URL)
+      hash_from_json = JSON.parse(inline_context)
+      hash_from_json["@context"] = Triannon::JsonldContext::IIIF_CONTEXT_URL
+      hash_from_json.to_json
+    end
+
+    # @return [String] the id of this annotation as a url
+    # TODO:  re-usable as part of Triannon::Graph class?
     def url
       if graph_exists?
-        solution = graph.query self.class.anno_query
+        solution = graph.query Triannon::Graph.anno_query
         if solution && solution.size == 1
           solution.first.s.to_s
         # TODO:  raise exception if no URL?
@@ -29,6 +95,7 @@ module Triannon
     end
 
     # FIXME:  this should be part of validation:  RDF.type should be RDF::OpenAnnotation.Annotation
+    # @return [String] should always be a string representation of RDF::OpenAnnotation.Annotation
     def type
       if graph_exists?
         q = RDF::Query.new
@@ -43,9 +110,11 @@ module Triannon
       end
     end
 
+    # @return [Array] of uris expressing the OA motivated_by values
+    # TODO:  re-usable as part of Triannon::Graph class?
     def motivated_by
       if graph_exists?
-        q = self.class.anno_query.dup
+        q = Triannon::Graph.anno_query.dup
         q << [:s, RDF::OpenAnnotation.motivatedBy, :motivated_by]
         solution = graph.query q
         if solution && solution.size > 0
@@ -59,67 +128,74 @@ module Triannon
       end
     end
 
-    def graph
-      @graph ||= data_to_graph
+protected
+
+    # TODO: WRITE_COMMENTS_AND_TESTS_FOR_THIS_METHOD
+    def solr_save
+#      puts "TO DO: send add to Solr (after save)"
+#      pp solr_hash
     end
 
-    def graph= g
-      @graph = g
+    # TODO: WRITE_COMMENTS_AND_TESTS_FOR_THIS_METHOD
+    def solr_delete
+#      puts "TO DO: send delete to Solr (after destroy)"
     end
     
-    # @return json-ld representation of graph with OpenAnnotation context as a url
-    def jsonld_oa
-      inline_context = graph.dump(:jsonld, :context => Triannon::JsonldContext::OA_CONTEXT_URL)
-      hash_from_json = JSON.parse(inline_context)
-      hash_from_json["@context"] = Triannon::JsonldContext::OA_CONTEXT_URL
-      hash_from_json.to_json
+    # TODO: WRITE_COMMENTS_AND_TESTS_FOR_THIS_METHOD
+    # TODO:  re-usable as part of Triannon::Graph class?
+    # 
+    # @return [Hash] a hash to be written to Solr, populated appropriately
+    def solr_hash
+      doc_hash = {}
+      tid = url.sub(Triannon.config[:ldp_url], "")
+      tid.sub(/^\//, "")
+      doc_hash[:id] = tid
+      doc_hash[:motivation] = motivated_by.map { |m| m.sub(RDF::OpenAnnotation.to_s, "") }
+      # date field format: 1995-12-31T23:59:59Z; or w fractional seconds: 1995-12-31T23:59:59.999Z
+#      doc_hash[:annotated_at] =
+#      doc_hash[:annotated_by_stem]
+      doc_hash[:target_url] = predicate_urls RDF::OpenAnnotation.hasTarget
+      doc_hash[:target_type] = ['external_URI'] if doc_hash[:target_url].size > 0
+      doc_hash[:body_url] = predicate_urls RDF::OpenAnnotation.hasBody
+      doc_hash[:body_type] = []
+      doc_hash[:body_type] << 'external_URI' if doc_hash[:body_url].size > 0
+      doc_hash[:body_chars_exact] = body_chars
+      doc_hash[:body_type] << 'content_as_text' if doc_hash[:body_chars_exact].size > 0
+      doc_hash[:body_type] << 'no_body' if doc_hash[:body_type].size == 0
+      doc_hash[:anno_jsonld] = jsonld_oa
+      doc_hash
     end
     
-    # @return json-ld representation of graph with IIIF context as a url
-    def jsonld_iiif
-      inline_context = graph.dump(:jsonld, :context => Triannon::JsonldContext::IIIF_CONTEXT_URL)
-      hash_from_json = JSON.parse(inline_context)
-      hash_from_json["@context"] = Triannon::JsonldContext::IIIF_CONTEXT_URL
-      hash_from_json.to_json
-    end
-
-    # query for a subject with type of RDF::OpenAnnotation.Annotation
-    def self.anno_query
-      @anno_query ||= begin
-        q = RDF::Query.new
-        q << [:s, RDF.type, RDF::URI("http://www.w3.org/ns/oa#Annotation")]
-      end
+    # TODO: WRITE_COMMENTS_AND_TESTS_FOR_THIS_METHOD
+    # TODO:  re-usable as part of Triannon::Graph class?
+    # @param [RDF::URI] predicate either RDF::OpenAnnotation.hasTarget or RDF::OpenAnnotation.hasBody
+    # @return [Array<String>] urls for the predicate, as an Array of Strings
+    def predicate_urls(predicate)
+      predicate_solns = graph.query([nil, predicate, nil])
+      urls = []
+      predicate_solns.each { |predicate_stmt |
+        predicate_obj = predicate_stmt.object
+        urls << predicate_obj.to_str if predicate_obj.is_a?(RDF::URI)
+      }
+      urls
     end
-
-    def self.create(attrs = {})
-      a = Triannon::Annotation.new attrs
-      a.save
-      a
-    end
-
-    def save
-      # check if valid?
-      graph
-      @id = Triannon::LdpCreator.create self
-    end
-
-    def destroy
-      Triannon::LdpDestroyer.destroy @id
-    end
-
-    def self.find(key)
-      oa_graph = Triannon::LdpLoader.load key
-      anno = Triannon::Annotation.new
-      anno.graph = oa_graph
-      anno.id = key
-      anno
-    end
-
-    def self.all
-      Triannon::LdpLoader.find_all
+    
+    # TODO: WRITE_COMMENTS_AND_TESTS_FOR_THIS_METHOD
+    # TODO:  re-usable as part of Triannon::Graph class?
+    # @return [Array<String>] body chars as Strings, in an Array (one element for each contentAsText body)
+    def body_chars
+      result = []
+      q = RDF::Query.new
+      q << [nil, RDF::OpenAnnotation.hasBody, :body]
+      q << [:body, RDF.type, RDF::Content.ContentAsText]
+      q << [:body, RDF::Content.chars, :body_chars]
+      solns = graph.query q
+      solns.each { |soln| 
+        result << soln.body_chars.value.strip
+      }
+      result
     end
 
-
 private
 
     # loads RDF::Graph from data attribute.  If data is in json-ld, converts it to turtle.

data/app/models/triannon/annotation_ldp.rb

@@ -14,12 +14,13 @@ module Triannon
     end
 
     def base_uri
-      res = graph.query anno_query
+      res = graph.query Triannon::Graph.anno_query
       res.first.s
     end
 
+    # @return [Array<String>] the uris of each LDP body resource
     def body_uris
-      q = anno_query
+      q = Triannon::Graph.anno_query.dup
       q << [:s, RDF::OpenAnnotation.hasBody, :body_uri]
       solns = graph.query q
       result = []
@@ -29,8 +30,9 @@ module Triannon
       result
     end
 
+    # @return [Array<String>] the uris of each LDP target resource
     def target_uris
-      q = anno_query
+      q = Triannon::Graph.anno_query.dup
       q << [:s, RDF::OpenAnnotation.hasTarget, :target_uri]
       solns = graph.query q
       result = []
@@ -46,11 +48,5 @@ module Triannon
       graph.insert(statements) if statements && statements.size > 0
     end
 
-private
-    def anno_query
-      q = RDF::Query.new
-      q << [:s, RDF.type, RDF::OpenAnnotation.Annotation]
-    end
-
   end
 end

data/app/services/triannon/ldp_to_oa_mapper.rb

@@ -24,9 +24,10 @@ module Triannon
           @id = stmnt.subject.to_s.split('/').last
           @root_uri = RDF::URI.new(Triannon.config[:triannon_base_url] + "/#{@id}")
           @oa_graph << [@root_uri, RDF.type, RDF::OpenAnnotation.Annotation]
-
         elsif stmnt.predicate == RDF::OpenAnnotation.motivatedBy
           @oa_graph << [@root_uri, stmnt.predicate, stmnt.object]
+        elsif stmnt.predicate == RDF::OpenAnnotation.annotatedAt
+          @oa_graph << [@root_uri, stmnt.predicate, stmnt.object]
         end
       end
     end
@@ -63,7 +64,7 @@ module Triannon
         external_uri = solns.first.object
         @oa_graph << [subject_obj, predicate, external_uri]
         
-        Triannon::LdpCreator.subject_statements(uri_obj, @ldp_anno_graph).each { |stmt|
+        Triannon::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
@@ -89,7 +90,7 @@ module Triannon
         blank_node = RDF::Node.new
         @oa_graph << [subject_obj, predicate, blank_node]
         
-        Triannon::LdpCreator.subject_statements(uri_obj, @ldp_anno_graph).each { |stmt|
+        Triannon::Graph.subject_statements(uri_obj, @ldp_anno_graph).each { |stmt|
           if stmt.subject == uri_obj
             @oa_graph << [blank_node, stmt.predicate, stmt.object]
           else
@@ -118,7 +119,7 @@ module Triannon
         source_obj = nil
         selector_obj = nil
         selector_blank_node = nil
-        specific_res_stmts = Triannon::LdpCreator.subject_statements(uri_obj, @ldp_anno_graph)
+        specific_res_stmts = Triannon::Graph.subject_statements(uri_obj, @ldp_anno_graph)
         specific_res_stmts.each { |stmt|
           if stmt.predicate == RDF::OpenAnnotation.hasSource
             # expecting a hash URI
@@ -170,7 +171,7 @@ module Triannon
         
         default_obj = nil
         item_objs = []
-        choice_stmts = Triannon::LdpCreator.subject_statements(uri_obj, @ldp_anno_graph)
+        choice_stmts = Triannon::Graph.subject_statements(uri_obj, @ldp_anno_graph)
         choice_stmts.each { |stmt|
           if stmt.predicate == RDF::OpenAnnotation.default
             default_obj = stmt.object

data/app/services/triannon/{ldp_creator.rb → ldp_writer.rb}

@@ -1,58 +1,58 @@
-
 module Triannon
 
-  # creates a new Annotation in the LDP server
-  class LdpCreator
+  # writes data/objects to the LDP server; also does deletes
+  class LdpWriter
 
     # use LDP protocol to create the OpenAnnotation.Annotation in an RDF store
     # @param [Triannon::Annotation] anno a Triannon::Annotation object, from which we use the graph
-    def self.create(anno)
+    def self.create_anno(anno)
       if anno && anno.graph
         # TODO:  special case if the Annotation object already has an id -- 
         #  see https://github.com/sul-dlss/triannon/issues/84
-        result = Triannon::LdpCreator.new anno
-        result.create_base
+        ldp_writer = Triannon::LdpWriter.new anno
+        id = ldp_writer.create_base
 
         bodies_solns = anno.graph.query([nil, RDF::OpenAnnotation.hasBody, nil])
         if bodies_solns.size > 0
-          result.create_body_container
-          result.create_body_resources
+          ldp_writer.create_body_container
+          ldp_writer.create_body_resources
         end
 
         targets_solns = anno.graph.query([nil, RDF::OpenAnnotation.hasTarget, nil])
         # NOTE:  Annotation is invalid if there are no target statements
         if targets_solns.size > 0
-          result.create_target_container
-          result.create_target_resources
+          ldp_writer.create_target_container
+          ldp_writer.create_target_resources
         end
 
-        result.id
+        id
       end
     end
 
-    # given an RDF::Resource (an RDF::Node or RDF::URI), look for all the statements with that object
-    #  as the subject, and recurse through the graph to find all descendant statements pertaining to the subject
-    # @param subject the RDF object to be used as the subject in the graph query.  Should be an RDF::Node or RDF::URI
-    # @param [RDF::Graph] graph
-    # @return [Array[RDF::Statement]] all the triples with the given subject
-    def self.subject_statements(subject, graph)
-      result = []
-      graph.query([subject, nil, nil]).each { |stmt|
-        result << stmt
-        subject_statements(stmt.object, graph).each { |s| result << s }
-      }
-      result.uniq
+    # deletes the indicated container and all its child containers from the LDP store
+    # @param [String] id the unique id for the LDP container for an annotation
+    #  May be a compound id, such as  uuid1/t/uuid2, in which case the LDP container object uuid2 and its children
+    #  are deleted from the LDP store, but LDP containers  uuid1/t  and uuid1  are not deleted from the LDP store.
+    def self.delete_container id
+      ldpw = Triannon::LdpWriter.new nil
+      ldpw.delete_containers id
     end
-
-    attr_accessor :id
-
+    
+    class << self
+      alias_method :delete_anno, :delete_container
+    end
+    
     # @param [Triannon::Annotation] anno a Triannon::Annotation object
-    def initialize(anno)
+    # @param [String] id the unique id for the LDP container for the passed annotation; defaults to nil
+    def initialize(anno, id=nil)
       @anno = anno
+      @id = id
       @base_uri = Triannon.config[:ldp_url]
     end
 
-    # POSTS a ttl representation of the LDP Annotation container to the LDP store
+    # creates a stored LDP container for this object's Annotation, without its targets or bodies (as those are put in descendant containers)
+    #   SIDE EFFECT:  assigns the uuid of the container created to @id
+    # @return [String] the unique id for the LDP container created for this annotation
     def create_base
       if @anno.graph.query([nil, RDF::Triannon.externalReference, nil]).count > 0
         raise Triannon::ExternalReferenceError, "Incoming annotations may not have http://triannon.stanford.edu/ns/externalReference as a predicate."
@@ -60,48 +60,15 @@ module Triannon
       
       # TODO:  special case if the Annotation object already has an id -- 
       #  see https://github.com/sul-dlss/triannon/issues/84
+      
+      # we need to work with a copy of the graph so we don't change @anno.graph
       g = RDF::Graph.new
       @anno.graph.each { |s|
         g << s
       }
-
-      # don't include the hasBody statements and any other statements associated with them
-      bodies_stmts = g.query([nil, RDF::OpenAnnotation.hasBody, nil])
-      bodies_stmts.each { |has_body_stmt|
-        g.delete has_body_stmt
-        body_obj = has_body_stmt.object
-        Triannon::LdpCreator.subject_statements(body_obj, g).each { |s|
-          g.delete s
-        }
-      }
-
-      # don't include the hasTarget statements and any other statements associated with them
-      targets_stmts = g.query([nil, RDF::OpenAnnotation.hasTarget, nil])
-      targets_stmts.each { |has_target_stmt|
-        g.delete has_target_stmt
-        target_obj = has_target_stmt.object
-        Triannon::LdpCreator.subject_statements(target_obj, g).each { |s|
-          g.delete s
-        }
-      }
-
-      # transform an outer blank node into a null relative URI
-      anno_stmts = g.query([nil, RDF.type, RDF::OpenAnnotation.Annotation])
-      anno_rdf_obj = anno_stmts.first.subject
-      if anno_rdf_obj.is_a?(RDF::Node)
-        # we need to use the null relative URI representation of blank nodes to write to LDP
-        anno_subject = RDF::URI.new
-      else # it's already a URI
-        anno_subject = anno_rdf_obj
-      end
-      Triannon::LdpCreator.subject_statements(anno_rdf_obj, g).each { |s|
-        if s.subject == anno_rdf_obj && anno_subject != anno_rdf_obj
-          g << RDF::Statement({:subject => anno_subject,
-                               :predicate => s.predicate,
-                               :object => s.object})
-          g.delete s
-        end
-      }
+      g = Triannon::Graph.new(g)
+      g.remove_non_base_statements
+      g.make_null_relative_uri_out_of_blank_node
 
       @id = create_resource g.to_ttl
     end
@@ -126,38 +93,68 @@ module Triannon
       create_resources_in_container RDF::OpenAnnotation.hasTarget
     end
 
-    def conn
-      @c ||= Faraday.new @base_uri
+    # @param [Array<String>] ldp_container_uris an Array of ids for LDP containers.  (can also be a String)
+    #  e.g. [@base_uri/(uuid1)/t/(uuid2), @base_uri/(uuid1)/t/(uuid3)] or [@base_uri/(uuid)] or (uuid)
+    # @return true if a resource was deleted;  false otherwise
+    def delete_containers ldp_container_uris
+      if ldp_container_uris.kind_of? String
+        ldp_container_uris = [ldp_container_uris]
+      end
+      something_deleted = false
+      ldp_container_uris.each { |uri|  
+        ldp_id = uri.to_s.split(@base_uri + '/').last
+        resp = conn.delete { |req| req.url ldp_id }
+        if resp.status != 204
+          raise "Unable to delete LDP container: #{ldp_id}\nResponse Status: #{resp.status}\nResponse Body: #{resp.body}"
+        end
+        something_deleted = true
+      }
+      something_deleted
     end
 
   protected
-    def create_resource body, url = nil
-      response = conn.post do |req|
-        req.url url if url
+
+    # POSTS a ttl representation of a graph to a newly created LDP container in the LDP store
+    # @param [String] ttl a turtle representation of RDF data to be put in the new LDP container
+    # @param [String] parent_path the path portion of the url for the LDP parent container for this resource
+    #   if no path is supplied, then the resource will be created as a child of the root annotation;
+    #   expected paths would also be (anno_id)/t  for a target resource (inside the target container of anno_id)
+    #   or (anno_id)/b for a body resource (inside the body container of anno_id)
+    # @return [String] uuid representing the unique id of the newly created LDP container
+    def create_resource ttl, parent_path = nil
+      resp = conn.post do |req|
+        req.url parent_path if parent_path
         req.headers['Content-Type'] = 'application/x-turtle'
-        req.body = body
+        req.body = ttl
+      end
+      if resp.status != 200 && resp.status != 201
+        raise "Unable to create LDP resource in container #{url}: Response Status: #{resp.status}\nResponse Body: #{resp.body}\nAnnotation sent: #{body}"
       end
-      new_url = response.headers['Location'] ? response.headers['Location'] : response.headers['location']
+      new_url = resp.headers['Location'] ? resp.headers['Location'] : resp.headers['location']
       new_url.split('/').last if new_url
     end
-
+  
     # Creates an empty LDP DirectContainer in LDP Storage that is a member of the base container and has the memberRelation per the oa_vocab_term
-    # The id of the created containter will be (base container id)b  if hasBody or  (base container id)/t  if hasTarget
+    # The id of the created containter will be (base container id)/b  if hasBody or  (base container id)/t  if hasTarget
     # @param [RDF::Vocabulary::Term] oa_vocab_term RDF::OpenAnnotation.hasTarget or RDF::OpenAnnotation.hasBody
     def create_direct_container oa_vocab_term
       null_rel_uri = RDF::URI.new
       g = RDF::Graph.new
       g << [null_rel_uri, RDF.type, RDF::LDP.DirectContainer]
       g << [null_rel_uri, RDF::LDP.hasMemberRelation, oa_vocab_term]
-      g << [null_rel_uri, RDF::LDP.membershipResource, RDF::URI.new("#{@base_uri}/#{id}")]
+      g << [null_rel_uri, RDF::LDP.membershipResource, RDF::URI.new("#{@base_uri}/#{@id}")]
 
-      response = conn.post do |req|
-        req.url "#{id}"
+      resp = conn.post do |req|
+        req.url "#{@id}"
         req.headers['Content-Type'] = 'application/x-turtle'
-        # OA vocab relationships all of form "hasXXX"
+        # OA vocab relationships all of form "hasXXX" so this becomes 't' or 'b'
         req.headers['Slug'] = oa_vocab_term.fragment.slice(3).downcase
         req.body = g.to_ttl
       end
+      if resp.status != 201
+        raise "Unable to create #{oa_vocab_term.fragment.sub('has', '')} LDP container for anno: Response Status: #{resp.status}\nResponse Body: #{resp.body}"
+      end
+      resp
     end
 
     # create the target/body resources inside the (already created) target/body container
@@ -193,7 +190,7 @@ module Triannon
         # add statements with predicate_obj as the subject
         orig_hash_uri_objs = [] # the orig URI objects from [targetObject, OA.hasSource/.default/.item, (uri)] statements
         hash_uri_counter = 1
-        Triannon::LdpCreator.subject_statements(predicate_obj, @anno.graph).each { |s|
+        Triannon::Graph.subject_statements(predicate_obj, @anno.graph).each { |s|
           if s.subject == predicate_obj
             # deal with any external URI references which may occur in: 
             #  OA.hasSource (from SpecificResource), OA.default or OA.item (from Choice, Composite, List)
@@ -229,7 +226,7 @@ module Triannon
                                                       :predicate => RDF::Triannon.externalReference,
                                                       :object => RDF::URI.new(orig_hash_uri_obj.to_s)})
                 # and all of the orig URL's addl props
-                Triannon::LdpCreator.subject_statements(orig_hash_uri_obj, @anno.graph).each { |ss|
+                Triannon::Graph.subject_statements(orig_hash_uri_obj, @anno.graph).each { |ss|
                   if ss.subject == orig_hash_uri_obj
                     graph_for_resource << RDF::Statement({:subject => new_hash_uri_obj,
                                                           :predicate => ss.predicate,
@@ -254,7 +251,7 @@ module Triannon
         # make sure the graph we will write contains no extraneous statements about URIs
         #  now represented as hash URIs
         orig_hash_uri_objs.each { |uri_node| 
-          Triannon::LdpCreator.subject_statements(uri_node, graph_for_resource).each { |s|  
+          Triannon::Graph.subject_statements(uri_node, graph_for_resource).each { |s|  
             graph_for_resource.delete(s)
           }
         }
@@ -266,6 +263,10 @@ module Triannon
       }
       resource_ids
     end
-    
+
+    def conn
+      @c ||= Faraday.new @base_uri
+    end
+
   end
-end
+end

data/config/solr/schema.xml

@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<schema name="Triannon" version="1.5">
+  <uniqueKey>id</uniqueKey>
+  <solrQueryParser defaultOperator="AND"/>
+  
+  <fields>
+    <!-- _version_ for SolrCloud -->
+    <field name="_version_" type="long" indexed="true" stored="true" multiValued="false"/> 
+    
+    <field name="id" type="string" stored="true" indexed="true" multiValued="false" required="true"/>
+    <field name="timestamp" type="date" stored="true" indexed="true" multiValued="false" default="NOW"/>
+
+    <field name="motivation" type="string" stored="true" indexed="true" multiValued="true"/>
+    <!-- date field format: 1995-12-31T23:59:59Z; or w fractional seconds: 1995-12-31T23:59:59.999Z -->
+    <field name="annotated_at" type="date" stored="true" indexed="true" multiValued="false"/>
+    <!-- trie field for range queries and faceting -->
+    <field name="annotated_at_tdate" type="tdate" stored="false" indexed="true" multiValued="false"/>
+    <field name="annotated_by_unstem" type="text_ws_lc" stored="false" indexed="true" multiValued="true"/>
+    <field name="annotated_by_stem" type="text_en" stored="true" indexed="true" multiValued="true"/>
+    <field name="target_url" type="url" stored="true" indexed="true" multiValued="true"/>
+    <field name="target_type" type="string" stored="true" indexed="true" multiValued="true"/>
+    <field name="body_url" type="url" stored="true" indexed="true" multiValued="true"/>
+    <field name="body_type" type="string" stored="true" indexed="true" multiValued="true"/>
+    <field name="body_chars_exact" type="alphaSort" stored="true" indexed="true" multiValued="true"/>
+    <field name="body_chars_unstem" type="text_ws_lc" stored="false" indexed="true" multiValued="true"/>
+    <field name="body_chars_stem" type="text_en" stored="false" indexed="true" multiValued="true"/>
+	
+    <field name="anno_jsonld" type="string" stored="true" indexed="false" multiValued="false"/>
+  </fields>
+
+  
+  <!-- unstemmed search fields -->
+  <copyField source="annotated_by_stem" dest="annotated_by_unstem" />
+  <copyField source="body_chars_exact" dest="body_chars_unstem" />
+  <copyField source="body_chars_exact" dest="body_chars_stem" />
+  <copyField source="annotated_at" dest="annotated_at_tdate" />
+ 
+
+  <types>
+    <fieldType name="string" class="solr.StrField" sortMissingLast="true" />
+    <fieldType name="boolean" class="solr.BoolField" sortMissingLast="true"/>    
+    <fieldType name="rand" class="solr.RandomSortField" omitNorms="true"/>
+    
+    <!-- Default numeric field types.  -->
+    <fieldType name="int" class="solr.TrieIntField" precisionStep="0" positionIncrementGap="0"/>
+    <fieldType name="float" class="solr.TrieFloatField" precisionStep="0" positionIncrementGap="0"/>
+    <fieldType name="long" class="solr.TrieLongField" precisionStep="0" positionIncrementGap="0"/>
+    <fieldType name="double" class="solr.TrieDoubleField" precisionStep="0" positionIncrementGap="0"/>
+    
+    <!-- trie numeric field types for faster range queries -->
+    <fieldType name="tint" class="solr.TrieIntField" precisionStep="8" positionIncrementGap="0"/>
+    <fieldType name="tfloat" class="solr.TrieFloatField" precisionStep="8" positionIncrementGap="0"/>
+    <fieldType name="tlong" class="solr.TrieLongField" precisionStep="8" positionIncrementGap="0"/>
+    <fieldType name="tdouble" class="solr.TrieDoubleField" precisionStep="8" positionIncrementGap="0"/>
+    
+    <!-- date field format: 1995-12-31T23:59:59Z; or w fractional seconds: 1995-12-31T23:59:59.999Z -->
+    <fieldType name="date" class="solr.TrieDateField" precisionStep="0" positionIncrementGap="0"/>
+    <!-- A Trie based date field for faster date range queries and date faceting. -->
+    <fieldType name="tdate" class="solr.TrieDateField" precisionStep="6" positionIncrementGap="0"/>
+        
+    <!-- A text field that only splits on whitespace and case folding for exact matching of words -->
+    <fieldType name="text_ws_lc" class="solr.TextField" positionIncrementGap="100">
+      <analyzer>
+        <tokenizer class="solr.WhitespaceTokenizerFactory"/>
+        <filter class="solr.ICUFoldingFilterFactory"/>
+      </analyzer>
+    </fieldType>
+        
+    <!-- single token analyzed text, for sorting.  Punctuation is significant. -->
+    <fieldtype name="alphaSort" class="solr.TextField" sortMissingLast="true" omitNorms="true">
+      <analyzer>
+  		<charFilter class="solr.PatternReplaceCharFilterFactory" pattern="\s+" replacement=" "/>
+        <tokenizer class="solr.KeywordTokenizerFactory" />
+        <filter class="solr.ICUFoldingFilterFactory"/>
+        <filter class="solr.TrimFilterFactory" />
+      </analyzer>
+    </fieldtype>
+
+    <!-- A text field with defaults appropriate for English -->
+    <fieldType name="text_en" class="solr.TextField" positionIncrementGap="100">
+      <analyzer>
+        <tokenizer class="solr.ICUTokenizerFactory"/>
+        <filter class="solr.ICUFoldingFilterFactory"/>
+        <filter class="solr.EnglishPossessiveFilterFactory"/>
+        <filter class="solr.EnglishMinimalStemFilterFactory"/>
+      </analyzer>
+    </fieldType>
+        
+    <!-- for urls - ignore http:// and https:// prefixes and trailing slash -->
+    <fieldType name="url" class="solr.TextField" positionIncrementGap="100">
+      <analyzer>
+		<charFilter class="solr.PatternReplaceCharFilterFactory" pattern="^\s*https?\:\/\/" replacement=""/>
+		<charFilter class="solr.PatternReplaceCharFilterFactory" pattern="\/\s*$" replacement=""/>
+        <tokenizer class="solr.KeywordTokenizerFactory" />
+        <filter class="solr.ICUFoldingFilterFactory"/>
+        <filter class="solr.TrimFilterFactory" />
+      </analyzer>
+    </fieldType>
+        
+  </types>
+  
+</schema>

data/config/solr/solrconfig.xml

@@ -0,0 +1,239 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- 
+     For more details about configurations options that may appear in
+     this file, see http://wiki.apache.org/solr/SolrConfigXml. 
+-->
+<config>
+  <luceneMatchVersion>4.7</luceneMatchVersion>
+
+  <dataDir>${solr.data.dir:}</dataDir>
+
+  <directoryFactory name="DirectoryFactory" class="${solr.directoryFactory:solr.NRTCachingDirectoryFactory}"/>
+  <codecFactory class="solr.SchemaCodecFactory"/>
+  <schemaFactory class="ClassicIndexSchemaFactory"/>
+
+  <indexConfig>
+    <lockType>${solr.lock.type:native}</lockType>
+    <unlockOnStartup>true</unlockOnStartup>
+  </indexConfig>
+
+  <jmx />
+
+  <updateHandler class="solr.DirectUpdateHandler2">
+    <updateLog>
+      <str name="dir">${solr.data.dir:}</str>
+    </updateLog>
+    <autoCommit>
+      <maxTime>15000</maxTime>
+      <openSearcher>false</openSearcher>
+    </autoCommit>
+  </updateHandler>
+
+  <query>
+    <maxBooleanClauses>1024</maxBooleanClauses>
+    <filterCache class="solr.FastLRUCache" size="512" initialSize="512" autowarmCount="0"/>
+    <queryResultCache class="solr.LRUCache" size="512" initialSize="512" autowarmCount="0"/>
+    <documentCache class="solr.LRUCache" size="512" initialSize="512" autowarmCount="0"/>
+    <enableLazyFieldLoading>true</enableLazyFieldLoading>
+    <queryResultWindowSize>20</queryResultWindowSize>
+    <queryResultMaxDocsCached>200</queryResultMaxDocsCached>
+
+    <!-- A New Searcher is opened when a (current) Searcher already exists..
+         It should only have the most common facets -->
+    <listener event="newSearcher" class="solr.QuerySenderListener">
+      <arr name="queries">
+		<lst>
+          <!-- default query for all objects: populate facet caches -->
+          <int name="rows">0</int>
+          <str name="fl">score</str>
+          <bool name="facet">true</bool>
+          <int name="facet.mincount">1</int>
+          <str name="facet.field">motivation</str>
+		    <str name="f.motivation.facet.method">enum</str>
+          <str name="facet.field">target_type</str>
+            <str name="f.target_type.facet.method">enum</str>
+          <str name="facet.field">body_type</str>
+            <str name="f.body_type.facet.method">enum</str>
+          <str name="facet.field">annotated_at_tdate</str>
+        </lst>
+		<lst>
+          <!-- single object query: populate filter and fieldValue caches -->
+          <str name="q">id:a*</str>
+          <str name="defType">lucene</str>
+          <int name="rows">0</int>
+          <str name="fl">score</str>
+          <bool name="facet">true</bool>
+          <int name="facet.mincount">1</int>
+          <str name="facet.field">motivation</str>
+            <str name="f.motivation.facet.method">enum</str>
+          <str name="facet.field">target_type</str>
+            <str name="f.target_type.facet.method">enum</str>
+		  <str name="facet.field">body_type</str>
+            <str name="f.body_type.facet.method">enum</str>
+          <str name="facet.field">annotated_at_tdate</str>
+        </lst>
+      </arr>
+    </listener>
+	
+    <!-- A First Searcher is opened when there is _no_ existing (current) Searcher. ("fast warmup") -->
+    <listener event="firstSearcher" class="solr.QuerySenderListener">
+      <arr name="queries">
+		<lst>
+          <!-- default query for all objects: populate facet caches -->
+          <int name="rows">0</int>
+          <str name="fl">score</str>
+          <bool name="facet">true</bool>
+          <int name="facet.mincount">1</int>
+          <str name="facet.field">motivation</str>
+            <str name="f.motivation.facet.method">enum</str>
+          <str name="facet.field">target_type</str>
+            <str name="f.target_type.facet.method">enum</str>
+		  <str name="facet.field">body_type</str>
+            <str name="f.body_type.facet.method">enum</str>
+        </lst>
+		<lst>
+          <!-- single object query: populate filter and fieldValue caches -->
+          <str name="q">id:a*</str>
+          <str name="defType">lucene</str>
+          <int name="rows">0</int>
+          <str name="fl">score</str>
+          <bool name="facet">true</bool>
+          <int name="facet.mincount">1</int>
+          <str name="facet.field">motivation</str>
+            <str name="f.motivation.facet.method">enum</str>
+          <str name="facet.field">target_type</str>
+            <str name="f.target_type.facet.method">enum</str>
+		  <str name="facet.field">body_type</str>
+            <str name="f.body_type.facet.method">enum</str>
+        </lst>
+      </arr>
+    </listener>
+
+    <useColdSearcher>true</useColdSearcher>
+    <maxWarmingSearchers>2</maxWarmingSearchers>
+  </query>
+
+  <requestDispatcher handleSelect="false" >
+    <requestParsers enableRemoteStreaming="true"
+                    multipartUploadLimitInKB="2048000"
+                    formdataUploadLimitInKB="2048"
+                    addHttpRequestToContext="false"/>
+  </requestDispatcher>
+
+  <requestHandler name="/select" class="solr.SearchHandler" default="true">
+    <lst name="defaults">
+      <str name="echoParams">explicit</str>
+	  <str name="sort">score desc, annotated_at_tdate desc</str>
+      <int name="rows">20</int>
+	  <str name="fl">* score</str>
+      <str name="wt">ruby</str>
+      <str name="indent">true</str>
+	  
+      <str name="defType">edismax</str>
+      <str name="q.alt">*:*</str>
+      <int name="qs">1</int>
+      <int name="ps">0</int>
+      <str name="mm">75%</str>
+      <float name="tie">0.01</float>
+      <bool name="lowercaseOperators">false</bool>
+      <!-- in case lucene query parser -->
+      <str name="df">anno_jsonld</str>
+      <str name="q.op">AND</str>
+	  
+	  <str name="qf">
+  	    body_chars_exact^3
+  	    body_chars_unstem^2
+  	    body_chars_stem
+	    annotated_by_unstem^2
+	    annotated_by_stem
+	    target_url
+	    body_url
+	    motivation
+	    id
+	  </str>
+	  <str name="pf"> <!-- (phrase boost within result set) -->
+    	body_chars_exact^15
+        body_chars_unstem^10
+        body_chars_stem^5
+  	    annotated_by_unstem^10
+  	    annotated_by_stem^5
+	  </str>
+	  <str name="pf3">  <!-- (token trigrams boost within result set) -->
+      	body_chars_exact^9
+        body_chars_unstem^6
+        body_chars_stem^3
+        annotated_by_unstem^6
+        annotated_by_stem^3
+	  </str>
+	  <str name="pf2"> <!--(token bigrams boost within result set) -->
+      	body_chars_exact^6
+        body_chars_unstem^4
+        body_chars_stem^2
+        annotated_by_unstem^4
+        annotated_by_stem^2
+	  </str>
+      
+	  <bool name="facet">true</bool>
+      <int name="facet.mincount">1</int>
+      <str name="facet.field">motivation</str>
+        <str name="f.motivation.facet.method">enum</str>
+      <str name="facet.field">target_type</str>
+        <str name="f.target_type.facet.method">enum</str>
+	  <str name="facet.field">body_type</str>
+        <str name="f.body_type.facet.method">enum</str>
+      <str name="facet.field">annotated_at_tdate</str>
+	  
+    </lst>
+  </requestHandler>
+
+  <!-- single document requests; use id=666 instead of q=id:666 -->
+  <requestHandler name="/doc" class="solr.SearchHandler" >
+    <lst name="defaults">
+      <str name="echoParams">explicit</str>
+      <str name="fl">anno_jsonld</str>
+      <int name="rows">1</int>
+      <str name="q">{!raw f=id v=$id}</str> <!-- use id=666 instead of q=id:666 -->
+      <str name="wt">ruby</str>
+      <str name="indent">true</str>
+    </lst>
+  </requestHandler>
+  
+  <requestHandler name="/update" class="solr.UpdateRequestHandler" />
+
+  <!-- required by SolrCloud -->
+  <requestHandler name="/replication" class="solr.ReplicationHandler" startup="lazy" />
+  <requestHandler name="/get" class="solr.RealTimeGetHandler">
+    <lst name="defaults">
+      <str name="omitHeader">true</str>
+    </lst>
+  </requestHandler>
+
+  <requestHandler name="/analysis/field" class="solr.FieldAnalysisRequestHandler" startup="lazy" />
+  <requestHandler name="/analysis/document" class="solr.DocumentAnalysisRequestHandler" startup="lazy" />
+  <requestHandler name="/admin/" class="solr.admin.AdminHandlers" />
+
+  <requestHandler name="/admin/ping" class="solr.PingRequestHandler">
+    <lst name="invariants">
+      <str name="q">solrpingquery</str>
+    </lst>
+    <lst name="defaults">
+      <str name="echoParams">all</str>
+    </lst>
+    <!-- <str name="healthcheckFile">server-enabled.txt</str> -->
+  </requestHandler>
+
+  <!-- Echo the request contents back to the client -->
+  <requestHandler name="/debug/dump" class="solr.DumpRequestHandler" startup="lazy">
+    <lst name="defaults">
+      <str name="echoParams">explicit</str>
+      <str name="echoHandler">true</str>
+    </lst>
+  </requestHandler>
+
+  <!-- Legacy config for the admin interface -->
+  <admin>
+    <defaultQuery>*:*</defaultQuery>
+  </admin>
+
+</config>
+

data/lib/generators/triannon/install_generator.rb

@@ -3,7 +3,7 @@ require 'rails/generators'
 module Triannon
   class Install < Rails::Generators::Base
     def inject_Triannon_routes
-      route "mount Triannon::Engine, at: 'annotations'"
+      route "mount Triannon::Engine, at: ''"
     end
 
     def create_triannon_yml_file

data/lib/triannon.rb

@@ -10,6 +10,7 @@ require 'faraday'
 module Triannon
   require "triannon/engine"
   require "triannon/error"
+  require "triannon/graph"
   require "triannon/jsonld_context"
 
   class << self

data/lib/triannon/graph.rb

@@ -0,0 +1,86 @@
+module Triannon
+  # a wrapper class for RDF::Graph that adds methods specific to Triannon
+  class Graph
+    
+    # given an RDF::Resource (an RDF::Node or RDF::URI), look for all the statements with that object
+    #  as the subject, and recurse through the graph to find all descendant statements pertaining to the subject
+    # @param subject the RDF object to be used as the subject in the graph query.  Should be an RDF::Node or RDF::URI
+    # @param [RDF::Graph] graph
+    # @return [Array[RDF::Statement]] all the triples with the given subject
+    def self.subject_statements(subject, graph)
+      result = []
+      graph.query([subject, nil, nil]).each { |stmt|
+        result << stmt
+        subject_statements(stmt.object, graph).each { |s| result << s }
+      }
+      result.uniq
+    end
+    
+    # @return [RDF::Query] query for a subject :s with type of RDF::OpenAnnotation.Annotation
+    def self.anno_query
+      q = RDF::Query.new
+      q << [:s, RDF.type, RDF::URI("http://www.w3.org/ns/oa#Annotation")]
+    end
+    
+    def initialize(rdf_graph)
+      @graph = rdf_graph
+    end
+    
+    # remove all RDF::OpenAnnotation.hasBody and .hasTarget statements
+    #  and any other statements associated with body and target objects, 
+    #  leaving all statements to be stored as part of base object in LDP store
+    def remove_non_base_statements
+      remove_has_target_statements
+      remove_has_body_statements
+    end
+    
+    # remove all RDF::OpenAnnotation.hasBody statements and any other statements associated with body objects
+    def remove_has_body_statements
+      remove_predicate_and_its_object_statements RDF::OpenAnnotation.hasBody
+    end
+    
+    # remove all RDF::OpenAnnotation.hasTarget statements and any other statements associated with body objects
+    def remove_has_target_statements
+      remove_predicate_and_its_object_statements RDF::OpenAnnotation.hasTarget
+    end
+    
+    # remove all such predicate statements and any other statements associated with predicates' objects
+    def remove_predicate_and_its_object_statements(predicate)
+      predicate_stmts = @graph.query([nil, predicate, nil])
+      predicate_stmts.each { |pstmt|
+        pred_obj = pstmt.object
+        Triannon::Graph.subject_statements(pred_obj, @graph).each { |s|
+          @graph.delete s
+        } unless !Triannon::Graph.subject_statements(pred_obj, @graph)
+        @graph.delete pstmt
+      }
+    end
+    
+    # transform an outer blank node into a null relative URI
+    def make_null_relative_uri_out_of_blank_node
+      anno_stmts = @graph.query([nil, RDF.type, RDF::OpenAnnotation.Annotation])
+      # FIXME: should actually look for subject with type of RDF::OpenAnnotation.Annotation
+      anno_rdf_obj = anno_stmts.first.subject
+      if anno_rdf_obj.is_a?(RDF::Node)
+        # we need to use the null relative URI representation of blank nodes to write to LDP
+        anno_subject = RDF::URI.new
+      else # it's already a URI
+        anno_subject = anno_rdf_obj
+      end
+      Triannon::Graph.subject_statements(anno_rdf_obj, @graph).each { |s|
+        if s.subject == anno_rdf_obj && anno_subject != anno_rdf_obj
+          @graph << RDF::Statement({:subject => anno_subject,
+                               :predicate => s.predicate,
+                               :object => s.object})
+          @graph.delete s
+        end
+      }
+    end
+    
+    # send unknown methods to RDF::Graph
+    def method_missing(sym, *args, &block)
+      @graph.send sym, *args, &block
+    end
+    
+  end
+end

data/lib/triannon/version.rb

@@ -1,3 +1,3 @@
 module Triannon
-  VERSION = "0.4.3"
+  VERSION = "0.4.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: triannon
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - Chris Beer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-08 00:00:00.000000000 Z
+date: 2015-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -257,10 +257,9 @@ files:
 - app/helpers/triannon/application_helper.rb
 - app/models/triannon/annotation.rb
 - app/models/triannon/annotation_ldp.rb
-- app/services/triannon/ldp_creator.rb
-- app/services/triannon/ldp_destroyer.rb
 - app/services/triannon/ldp_loader.rb
 - app/services/triannon/ldp_to_oa_mapper.rb
+- app/services/triannon/ldp_writer.rb
 - app/services/triannon/root_annotation_creator.rb
 - app/views/layouts/triannon/application.html.erb
 - app/views/triannon/annotations/_form.html.erb
@@ -270,6 +269,8 @@ files:
 - app/views/triannon/annotations/show.html.erb
 - config/initializers/mime_types.rb
 - config/routes.rb
+- config/solr/schema.xml
+- config/solr/solrconfig.xml
 - config/triannon.yml
 - lib/generators/triannon/install_generator.rb
 - lib/rdf/triannon_vocab.rb
@@ -277,6 +278,7 @@ files:
 - lib/triannon.rb
 - lib/triannon/engine.rb
 - lib/triannon/error.rb
+- lib/triannon/graph.rb
 - lib/triannon/iiif_presentation_2_context.json
 - lib/triannon/jsonld_context.rb
 - lib/triannon/oa_context_20130208.json

data/app/services/triannon/ldp_destroyer.rb

@@ -1,15 +0,0 @@
-
-module Triannon
-
-  class LdpDestroyer
-
-    def self.destroy key
-      conn = Faraday.new Triannon.config[:ldp_url]
-
-      resp = conn.delete { |req| req.url key }
-      if resp.status != 204
-        raise "Unable to delete Annotation: #{key}\nResponse Status: #{resp.status}\nResponse Body: #{resp.body}"
-      end
-    end
-  end
-end