triannon 0.0.3 → 0.0.4

data/app/services/triannon/ldp_creator.rb

@@ -0,0 +1,265 @@
+
+module Triannon
+
+  # creates a new Annotation in the LDP server
+  class LdpCreator
+
+    # 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)
+      # TODO:  we should not get here if the Annotation object already has an id
+      result = Triannon::LdpCreator.new anno
+      result.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
+      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
+      end
+
+      result.id
+    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
+    end
+
+    attr_accessor :id
+
+    # @param [Triannon::Annotation] anno a Triannon::Annotation object
+    def initialize(anno)
+      @anno = anno
+      @base_uri = Triannon.config[:ldp_url]
+    end
+
+    # POSTS a ttl representation of the LDP Annotation container to the LDP store
+    def create_base
+      # TODO:  we should error if the Annotation object already has an id
+
+      g = RDF::Graph.new
+      @anno.graph.each { |s|
+        g << s
+      }
+
+      # remove 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
+        }
+      }
+
+      # remove 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
+      }
+
+      @id = create_resource g.to_ttl
+    end
+
+    # creates the LDP container for any and all bodies for this annotation
+    def create_body_container
+      create_direct_container RDF::OpenAnnotation.hasBody
+    end
+
+    # creates the LDP container for any and all targets for this annotation
+    def create_target_container
+      create_direct_container RDF::OpenAnnotation.hasTarget
+    end
+
+    # create the body resources inside the (already created) body container
+    def create_body_resources
+      bodies_solns = @anno.graph.query([nil, RDF::OpenAnnotation.hasBody, nil])
+      body_ids = []
+      bodies_solns.each { |has_body_stmt |
+        graph_for_resource = RDF::Graph.new
+        body_obj = has_body_stmt.object
+        if body_obj.is_a?(RDF::Node)
+          # we need to use the null relative URI representation of blank nodes to write to LDP
+          body_subject = RDF::URI.new
+        else 
+          # it's already a URI, but we need to use the null relative URI representation so we can
+          # write out as a Triannon:externalRef property with the URL, and any addl props too.
+          if body_obj.to_str
+            body_subject = RDF::URI.new
+            graph_for_resource << RDF::Statement({:subject => body_subject,
+                                                  :predicate => RDF::Triannon.externalReference,
+                                                  :object => RDF::URI.new(body_obj.to_str)})
+            addl_stmts = @anno.graph.query([body_obj, nil, nil])
+            addl_stmts.each { |s|  
+              graph_for_resource << RDF::Statement({:subject => body_subject,
+                                                    :predicate => s.predicate,
+                                                    :object => s.object})
+            }
+          else # it's already a null relative URI
+            body_subject = body_obj
+          end
+        end
+        # add statements with body_obj as the subject
+        Triannon::LdpCreator.subject_statements(body_obj, @anno.graph).each { |s|
+          if s.subject == body_obj
+            graph_for_resource << RDF::Statement({:subject => body_subject,
+                                                  :predicate => s.predicate,
+                                                  :object => s.object})
+          else
+            graph_for_resource << s
+          end
+        }
+        body_ids << create_resource(graph_for_resource.to_ttl, "#{@id}/b")
+      }
+      body_ids
+    end
+
+    # create the target resources inside the (already created) target container
+    def create_target_resources
+      target_solns = @anno.graph.query([nil, RDF::OpenAnnotation.hasTarget, nil])
+      target_ids = []
+      target_solns.each { |has_target_stmt |
+        graph_for_resource = RDF::Graph.new
+        target_obj = has_target_stmt.object
+        if target_obj.is_a?(RDF::Node)
+          # we need to use the null relative URI representation of blank nodes to write to LDP
+          target_subject = RDF::URI.new
+        else 
+          # it's already a URI, but we need to use the null relative URI representation so we can
+          # write out as a Triannon:externalRef property with the URL, and any addl props too.
+          if target_obj.to_str
+            target_subject = RDF::URI.new
+            graph_for_resource << RDF::Statement({:subject => target_subject,
+                                                  :predicate => RDF::Triannon.externalReference,
+                                                  :object => RDF::URI.new(target_obj.to_str)})
+            addl_stmts = @anno.graph.query([target_obj, nil, nil])
+            addl_stmts.each { |s|  
+              graph_for_resource << RDF::Statement({:subject => target_subject,
+                                                    :predicate => s.predicate,
+                                                    :object => s.object})
+            }
+          else # it's already a null relative URI
+            target_subject = target_obj
+          end
+        end
+        # add statements with target_obj as the subject
+        orig_source_objects = [] # the object URI nodes  from  targetObject, OA.hasSource, (uri) statements
+        Triannon::LdpCreator.subject_statements(target_obj, @anno.graph).each { |s|
+          if s.subject == target_obj
+            # deal with external references in hasSource statements (i.e.  targetObject, OA.hasSource, (url) )
+            if s.predicate == RDF::OpenAnnotation.hasSource && s.object.is_a?(RDF::URI) && s.object.to_str
+              # we need to represent the source URL as an externalReference - use a hash URI
+              source_object = RDF::URI.new("#source")
+              orig_source_objects << s.object
+              graph_for_resource << RDF::Statement({:subject => source_object,
+                                                    :predicate => RDF::Triannon.externalReference,
+                                                    :object => RDF::URI.new(s.object.to_str)})
+              # and all of the source URL's addl props
+              Triannon::LdpCreator.subject_statements(s.object, @anno.graph).each { |ss|
+                if ss.subject == s.object
+                  graph_for_resource << RDF::Statement({:subject => source_object,
+                                                        :predicate => ss.predicate,
+                                                        :object => ss.object})
+                else
+                  graph_for_resource << ss
+                end
+              }
+              # add the targetObj, OA.hasSource, (hash URI representation) to graph
+              graph_for_resource << RDF::Statement({:subject => target_subject,
+                                                    :predicate => s.predicate,
+                                                    :object => source_object})
+            else
+              graph_for_resource << RDF::Statement({:subject => target_subject,
+                                                    :predicate => s.predicate,
+                                                    :object => s.object})
+            end
+          else
+            graph_for_resource << s
+          end
+        }
+        # make sure the graph we will write contains no extraneous statements about source URI
+        #  now represented as hash URI (#source)
+        orig_source_objects.each { |rdf_uri_node| 
+          Triannon::LdpCreator.subject_statements(rdf_uri_node, graph_for_resource).each { |s|  
+            graph_for_resource.delete(s)
+          }
+        }
+        target_ids << create_resource(graph_for_resource.to_ttl, "#{@id}/t")
+      }
+      target_ids
+    end
+
+    def conn
+      @c ||= Faraday.new @base_uri
+    end
+
+  protected
+    def create_resource body, url = nil
+      response = conn.post do |req|
+        req.url url if url
+        req.headers['Content-Type'] = 'application/x-turtle'
+        req.body = body
+      end
+      new_url = response.headers['Location'] ? response.headers['Location'] : response.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
+    # @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}")]
+
+      response = conn.post do |req|
+        req.url "#{id}"
+        req.headers['Content-Type'] = 'application/x-turtle'
+        # OA vocab relationships all of form "hasXXX"
+        req.headers['Slug'] = oa_vocab_term.fragment.slice(3).downcase
+        req.body = g.to_ttl
+      end
+    end
+
+  end
+end

data/app/services/triannon/ldp_destroyer.rb

@@ -0,0 +1,15 @@
+
+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

data/app/services/triannon/ldp_loader.rb

@@ -0,0 +1,82 @@
+
+module Triannon
+
+  # Loads an existing Annotation from the LDP server
+  class LdpLoader
+
+    def self.load key
+      l = Triannon::LdpLoader.new key
+      l.load_annotation
+      l.load_body
+      l.load_target
+
+      oa_graph = Triannon::LdpToOaMapper.ldp_to_oa l.annotation
+      oa_graph
+    end
+
+    def self.find_all
+      l = Triannon::LdpLoader.new
+      l.find_all
+    end
+
+    attr_accessor :annotation
+
+    def initialize key = nil
+      @key = key
+      @base_uri = Triannon.config[:ldp_url]
+      @annotation = Triannon::AnnotationLdp.new
+    end
+
+    def load_annotation
+      @annotation.load_data_into_graph get_ttl @key
+    end
+
+    def load_body
+      @annotation.body_uris.each { |body_uri|  
+        sub_path = body_uri.to_s.split(@base_uri + '/').last
+        @annotation.load_data_into_graph get_ttl sub_path
+      }
+    end
+
+    def load_target
+      @annotation.target_uris.each { |target_uri| 
+        sub_path = target_uri.to_s.split(@base_uri + '/').last
+        @annotation.load_data_into_graph get_ttl sub_path
+      }
+    end
+    
+    # @return [Array<Triannon::Annotation>] an array of Triannon::Annotation objects with just the id set. Enough info to build the index page
+    def find_all
+      root_ttl = get_ttl
+      objs = []
+
+      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.each do |stmt|
+        id = stmt.object.to_s.split('/').last
+        objs << Triannon::Annotation.new(:id => id)
+      end
+
+      objs
+    end
+
+    protected
+
+    def get_ttl sub_path = nil
+      resp = conn.get do |req|
+        req.url "#{sub_path}" if sub_path
+        req.headers['Accept'] = 'text/turtle'
+      end
+      resp.body
+    end
+
+    def conn
+      @c ||= Faraday.new @base_uri
+    end
+
+  end
+
+
+end

data/app/services/triannon/ldp_to_oa_mapper.rb

@@ -0,0 +1,61 @@
+module Triannon
+  class LdpToOaMapper
+
+    # maps an AnnotationLdp to an OA RDF::Graph
+    def self.ldp_to_oa ldp_anno
+      mapper = Triannon::LdpToOaMapper.new ldp_anno
+      mapper.extract_base
+      mapper.extract_body
+      mapper.extract_target
+      mapper.oa_graph
+    end
+
+    attr_accessor :id, :oa_graph
+
+    def initialize ldp_anno
+      @ldp = ldp_anno
+      @oa_graph = RDF::Graph.new
+    end
+
+    def extract_base
+      @ldp.stripped_graph.each_statement do |stmnt|
+        if stmnt.predicate == RDF.type && stmnt.object == RDF::OpenAnnotation.Annotation
+          @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]
+        end
+      end
+    end
+
+    def extract_body
+      @ldp.body_uris.each { |body_uri|  
+        res = @ldp.stripped_graph.query [body_uri, RDF.type, RDF::Content.ContentAsText]
+        if res.count > 0 # TODO raise if this fails?
+          body_node = RDF::Node.new
+          @oa_graph << [@root_uri, RDF::OpenAnnotation.hasBody, body_node]
+          @oa_graph << [body_node, RDF.type, RDF::Content.ContentAsText]
+          @oa_graph << [body_node, RDF.type, RDF::DCMIType.Text]
+          res_chars = @ldp.stripped_graph.query [body_uri, RDF::Content.chars, nil]
+          if res_chars.count > 0
+            @oa_graph << [body_node, RDF::Content.chars, res_chars.first.object]
+          end
+        end
+      }
+    end
+
+    def extract_target
+      @ldp.target_uris.each { |target_uri|  
+        res = @ldp.stripped_graph.query [target_uri, RDF::Triannon.externalReference, nil]
+        if res.count > 0
+          ext_uri = res.first.object
+          @oa_graph << [@root_uri, RDF::OpenAnnotation.hasTarget, ext_uri]
+        end
+      }
+    end
+
+  end
+
+end

data/app/services/triannon/root_annotation_creator.rb

@@ -0,0 +1,36 @@
+module Triannon
+
+  class RootAnnotationCreator
+
+     # Creates an LDP Container to hold all the annotations
+     # Called from config/initializers/root_annotation_container.rb during app bootup
+     # @return [Boolean] true if the root container was created, false if the container already exists or if there were issues
+     def self.create
+       conn = Faraday.new :url => Triannon.config[:ldp_url]
+       resp = conn.head
+       unless resp.status == 404 || resp.status == 410
+         Rails.logger.info "Root annotation resource already created."
+         return false
+       end
+
+       uri = RDF::URI.new Triannon.config[:ldp_url]
+       conn = Faraday.new :url => uri.parent.to_s
+       slug = uri.to_s.split('/').last
+
+       resp = conn.post do |req|
+         req.headers['Content-Type'] = 'text/turtle'
+         req.headers['Slug'] = slug
+       end
+
+       if resp.status == 201
+         Rails.logger.info "Created root annotation container #{Triannon.config[:ldp_url]}"
+         return true
+       else
+         Rails.logger.warn "Unable to create root annotation container #{Triannon.config[:ldp_url]}"
+         return false
+         # TODO raise an exception if we get here?
+       end
+     end
+
+  end
+end