triannon 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9936254da42efbcc7d7225b4f684097a2ac84f0f
-  data.tar.gz: b0d8e6bcba4019fc9cef4300f484f7a2d11774db
+  metadata.gz: 98b04d335bf8e2b24385cfeb4088d9c8db62c5c8
+  data.tar.gz: e10c1dc27cd105c7acb4fee6de77f8f51dddac9e
 SHA512:
-  metadata.gz: 90a6538ea8c10582a4e06f1e159947b1013784d7f2b7c8474811f13534f3c4806ed559b2456b304c5d51ce688d0b5f2ff44b2a43b518a181827fd3a32b3276bc
-  data.tar.gz: efda4aab06e7a5939d44e61ab6a860be835b20301c2f699291b1b246ae59e3820563720860c0ef307fbb1b9d4447b695ed911fbd7534df4f16419f77a2dce349
+  metadata.gz: 6f46652fb5c45b9b47be3374919eb4fd9bcf79ae50bf69059ee3896640990cedd11c499684185ea85d9befb6820c17ec8e6e84fc6425fbd7cef979dc57b6ef31
+  data.tar.gz: e3967493035299c17a6e7235f288e0b212738e94b9817806869fb4fb737bb6508e72c05607372718e6e84738ba85cca2d5597143ca723cf148457e2a003a6976

data/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/sul-dlss/triannon.svg?branch=master)](https://travis-ci.org/sul-dlss/triannon) [![Dependency Status](https://gemnasium.com/sul-dlss/triannon.svg)](https://gemnasium.com/sul-dlss/triannon) [![Gem Version](https://badge.fury.io/rb/triannon.svg)](http://badge.fury.io/rb/triannon)
+[![Build Status](https://travis-ci.org/sul-dlss/triannon.svg?branch=master)](https://travis-ci.org/sul-dlss/triannon) [![Coverage Status](https://coveralls.io/repos/sul-dlss/triannon/badge.png)](https://coveralls.io/r/sul-dlss/triannon) [![Dependency Status](https://gemnasium.com/sul-dlss/triannon.svg)](https://gemnasium.com/sul-dlss/triannon) [![Gem Version](https://badge.fury.io/rb/triannon.svg)](http://badge.fury.io/rb/triannon)
 
 # Triannon
 

data/app/controllers/triannon/annotations_controller.rb

@@ -4,6 +4,7 @@ module Triannon
   class AnnotationsController < ApplicationController
     before_action :default_format_jsonld, only: [:show]
     before_action :set_annotation, only: [:show, :edit, :update, :destroy]
+    rescue_from Triannon::ExternalReferenceError, with: :ext_ref_error
 
     # GET /annotations/annotations
     def index
@@ -95,5 +96,10 @@ module Triannon
           end
         end
       end
+      
+      # handle Triannon::ExternalReferenceError
+      def ext_ref_error(exception)
+        render plain: exception.message, status: 403
+      end
   end
 end

data/app/models/triannon/annotation.rb

@@ -178,7 +178,12 @@ private
     end
 
     def json_oa_context
-      @json_oa_context ||= File.read("lib/triannon/oa_context_20130208.json")
+      # FIXME:  this is a terrible place to do this!!
+      if Rails.root.to_s.match(/internal/) # testing via engine_cart
+        @json_oa_context ||= File.read(Rails.root.join("..", "..", "lib", "triannon", "oa_context_20130208.json"))
+      else
+        @json_oa_context ||= File.read(Rails.root.join("lib", "triannon", "oa_context_20130208.json"))
+      end
     end
 
     def graph_exists?

data/app/models/triannon/annotation_ldp.rb

@@ -1,4 +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.
   class AnnotationLdp
 
     # RDF::Graph object with all triples, including back end (e.g. LDP, Fedora)
@@ -8,9 +10,7 @@ module Triannon
 
     # RDF::Graph without any back end (e.g. LDP, Fedora) triples
     def stripped_graph
-      @stripped_graph ||= begin
-        new_graph = RDF::LDP.remove_ldp_triples (RDF::FCRepo4.remove_fedora_triples(graph))
-      end
+      RDF::LDP.remove_ldp_triples (RDF::FCRepo4.remove_fedora_triples(graph))
     end
 
     def base_uri
@@ -39,9 +39,11 @@ module Triannon
       }
       result
     end
-
-    def load_data_into_graph ttl
-      graph.from_ttl ttl
+    
+    # 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
+      graph.insert(statements) if statements && statements.size > 0
     end
 
 private

data/app/models/triannon/graph_validator.rb

@@ -0,0 +1,33 @@
+module Triannon
+  class GraphValidator < ActiveModel::Validator
+    
+    def validate(anno)
+      graph_exists? anno
+      graph = anno.graph
+      basic_solution = graph.query(self.basic_query)
+      unless basic_solution && basic_solution.size == 1
+        anno.errors[:data] << 'The oa:Annotation class MUST be associated with each Annotation.'
+        anno.errors[:data] << 'each Annotation MUST have at least one target'
+      end      
+    end
+    
+    def graph_exists?(anno)
+      graph = anno.graph
+      unless graph && graph.size > 0
+        anno.errors[:data] << 'Unable to create non-null graph'
+      end
+    end
+    
+    # query for a subject with 
+    #  predicate  RDF::OpenAnnotation.hasTarget  
+    #  type of RDF::OpenAnnotation.Annotation
+    def self.basic_query
+      @@basic_query ||= begin
+        RDF::Query.new
+        basic_query << [:s, RDF.type, RDF::URI("http://www.w3.org/ns/oa#Annotation")]
+        basic_query << [:s, RDF::OpenAnnotation.hasTarget, nil]
+      end
+    end
+    
+  end
+end

data/app/services/triannon/ldp_creator.rb

@@ -7,24 +7,27 @@ module Triannon
     # 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
+      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
 
-      bodies_solns = anno.graph.query([nil, RDF::OpenAnnotation.hasBody, nil])
-      if bodies_solns.size > 0
-        result.create_body_container
-        result.create_body_resources
-      end
+        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
+        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
+        result.id
+      end
     end
 
     # given an RDF::Resource (an RDF::Node or RDF::URI), look for all the statements with that object
@@ -51,16 +54,20 @@ module Triannon
 
     # 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
-
+      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."
+      end
+      
+      # TODO:  special case if the Annotation object already has an id -- 
+      #  see https://github.com/sul-dlss/triannon/issues/84
       g = RDF::Graph.new
       @anno.graph.each { |s|
         g << s
       }
 
-      # remove the hasBody statements and any other statements associated with them
+      # 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 |
+      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|
@@ -68,9 +75,9 @@ module Triannon
         }
       }
 
-      # remove the hasTarget statements and any other statements associated with them
+      # 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 |
+      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|
@@ -111,120 +118,12 @@ module Triannon
 
     # 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
+      create_resources_in_container RDF::OpenAnnotation.hasBody
     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
+      create_resources_in_container RDF::OpenAnnotation.hasTarget
     end
 
     def conn
@@ -261,5 +160,112 @@ module Triannon
       end
     end
 
+    # create the target/body resources inside the (already created) target/body container
+    # @param [RDF::URI] predicate either RDF::OpenAnnotation.hasTarget or RDF::OpenAnnotation.hasBody
+    def create_resources_in_container(predicate)
+      predicate_solns = @anno.graph.query([nil, predicate, nil])
+      resource_ids = []
+      predicate_solns.each { |predicate_stmt |
+        graph_for_resource = RDF::Graph.new
+        predicate_obj = predicate_stmt.object
+        if predicate_obj.is_a?(RDF::Node)
+          # we need to use the null relative URI representation of blank nodes to write to LDP
+          predicate_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 predicate_obj.to_str
+            predicate_subject = RDF::URI.new
+            graph_for_resource << RDF::Statement({:subject => predicate_subject,
+                                                  :predicate => RDF::Triannon.externalReference,
+                                                  :object => RDF::URI.new(predicate_obj.to_str)})
+            addl_stmts = @anno.graph.query([predicate_obj, nil, nil])
+            addl_stmts.each { |s|  
+              graph_for_resource << RDF::Statement({:subject => predicate_subject,
+                                                    :predicate => s.predicate,
+                                                    :object => s.object})
+            }
+          else # it's already a null relative URI
+            predicate_subject = predicate_obj
+          end
+        end
+        
+        # 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|
+          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)
+            if s.object.is_a?(RDF::URI) && s.object.to_s
+              # do we need to represent the URL as an externalReference with hash URI
+              if s.predicate == RDF::OpenAnnotation.hasSource
+                hash_uri_str = "#source"
+              elsif s.predicate == RDF::OpenAnnotation.default
+                hash_uri_str = "#default"
+              elsif s.predicate == RDF::OpenAnnotation.item
+                hash_uri_str = "#item#{hash_uri_counter}"
+                hash_uri_counter = hash_uri_counter + 1
+              else
+                # we don't need to represent the object URI as an external ref
+                hash_uri_str = nil
+                graph_for_resource << RDF::Statement({:subject => predicate_subject,
+                                                      :predicate => s.predicate,
+                                                      :object => s.object})
+              end
+              
+              if hash_uri_str
+                # represent the object URL as an external ref
+                new_hash_uri_obj = RDF::URI.new(hash_uri_str)
+                orig_hash_uri_obj = s.object
+                orig_hash_uri_objs << orig_hash_uri_obj
+                # add [targetObj, OA.hasSource/.default/.item, (hash URI)] triple to graph
+                graph_for_resource << RDF::Statement({:subject => predicate_subject,
+                                                      :predicate => s.predicate,
+                                                      :object => new_hash_uri_obj})
+                
+                # add externalReference triple to graph
+                graph_for_resource << RDF::Statement({:subject => new_hash_uri_obj,
+                                                      :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|
+                  if ss.subject == orig_hash_uri_obj
+                    graph_for_resource << RDF::Statement({:subject => new_hash_uri_obj,
+                                                          :predicate => ss.predicate,
+                                                          :object => ss.object})
+                  else
+                    graph_for_resource << ss
+                  end
+                }
+              end
+              # NOTE: already dealt with case where there is no hash uri above
+            else
+              # s.object is not a URI, and subject = predicate_subject -- it may be a blank node
+              graph_for_resource << RDF::Statement({:subject => predicate_subject,
+                                                    :predicate => s.predicate,
+                                                    :object => s.object})
+            end
+          else 
+            # s.subject != predicate_obj 
+            graph_for_resource << s
+          end
+        }
+        # 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|  
+            graph_for_resource.delete(s)
+          }
+        }
+        if (predicate == RDF::OpenAnnotation.hasTarget)
+          resource_ids << create_resource(graph_for_resource.to_ttl, "#{@id}/t")
+        else
+          resource_ids << create_resource(graph_for_resource.to_ttl, "#{@id}/b")
+        end
+      }
+      resource_ids
+    end
+    
   end
 end

data/app/services/triannon/ldp_loader.rb

@@ -6,11 +6,11 @@ module Triannon
 
     def self.load key
       l = Triannon::LdpLoader.new key
-      l.load_annotation
-      l.load_body
-      l.load_target
+      l.load_anno_container
+      l.load_bodies
+      l.load_targets
 
-      oa_graph = Triannon::LdpToOaMapper.ldp_to_oa l.annotation
+      oa_graph = Triannon::LdpToOaMapper.ldp_to_oa l.ldp_annotation
       oa_graph
     end
 
@@ -19,29 +19,32 @@ module Triannon
       l.find_all
     end
 
-    attr_accessor :annotation
+    attr_accessor :ldp_annotation
 
     def initialize key = nil
       @key = key
       @base_uri = Triannon.config[:ldp_url]
-      @annotation = Triannon::AnnotationLdp.new
+      @ldp_annotation = Triannon::AnnotationLdp.new
     end
 
-    def load_annotation
-      @annotation.load_data_into_graph get_ttl @key
+    # load annotation container object into @ldp_annotation's (our Triannon::AnnotationLdp object) graph
+    def load_anno_container
+      load_object_into_annotation_graph(@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
+    # load body objects into @ldp_annotation's (our Triannon::AnnotationLdp object) graph
+    def load_bodies
+      @ldp_annotation.body_uris.each { |body_uri|  
+        body_obj_path = body_uri.to_s.split(@base_uri + '/').last
+        load_object_into_annotation_graph(body_obj_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
+    # load target objects into @ldp_annotation's (our Triannon::AnnotationLdp object) graph
+    def load_targets
+      @ldp_annotation.target_uris.each { |target_uri| 
+        target_obj_path = target_uri.to_s.split(@base_uri + '/').last
+        load_object_into_annotation_graph(target_obj_path)
       }
     end
     
@@ -64,19 +67,36 @@ module Triannon
 
     protected
 
+    # given a path to the back end storage url, retrieve the object from storage and load
+    #  the triples (except storage specific triples) into the graph for @ldp_annotation, our Triannon::AnnotationLdp object
+    # @param [String] path the path to the object, e.g. the pid, or  pid/t/target_pid
+    def load_object_into_annotation_graph(path)
+      @ldp_annotation.load_statements_into_graph(statements_from_ttl_minus_fedora(get_ttl path))
+    end
+
+    # gets object from back end storage as turtle serialization
     def get_ttl sub_path = nil
       resp = conn.get do |req|
         req.url "#{sub_path}" if sub_path
-        req.headers['Accept'] = 'text/turtle'
+        req.headers['Accept'] = 'application/x-turtle'
       end
       resp.body
     end
 
+    # turns turtle serialization into Array of RDF::Statements, removing fedora-specific triples
+    #  (leaving LDP and OA triples)
+    # @param [String] ttl a String containing RDF serialized as turtle
+    # @return [Array<RDF::Statements>] the RDF statements represented in the ttl 
+    def statements_from_ttl_minus_fedora ttl
+      # RDF::Turtle::Reader.new(ttl).statements.to_a
+      g = RDF::Graph.new.from_ttl(ttl)
+      RDF::FCRepo4.remove_fedora_triples(g).statements
+    end
+
     def conn
       @c ||= Faraday.new @base_uri
     end
 
   end
 
-
 end

data/app/services/triannon/ldp_to_oa_mapper.rb

@@ -5,20 +5,21 @@ module Triannon
     def self.ldp_to_oa ldp_anno
       mapper = Triannon::LdpToOaMapper.new ldp_anno
       mapper.extract_base
-      mapper.extract_body
-      mapper.extract_target
+      mapper.extract_bodies
+      mapper.extract_targets
       mapper.oa_graph
     end
 
     attr_accessor :id, :oa_graph
 
     def initialize ldp_anno
-      @ldp = ldp_anno
+      @ldp_anno = ldp_anno
+      @ldp_anno_graph = ldp_anno.stripped_graph
       @oa_graph = RDF::Graph.new
     end
 
     def extract_base
-      @ldp.stripped_graph.each_statement do |stmnt|
+      @ldp_anno_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}")
@@ -30,31 +31,175 @@ module Triannon
       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
+    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)
         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]
+    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)
         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
+    # @param [RDF::URI] the subject object to get the predicate statement; defaults to @root_uri
+    # @returns [Boolean] true if it adds statements to @oa_graph, false otherwise
+    def map_external_ref uri_obj, predicate, subject_obj = @root_uri
+      solns = @ldp_anno_graph.query [uri_obj, RDF::Triannon.externalReference, nil]
+      if solns.count > 0
+        external_uri = solns.first.object
+        @oa_graph << [subject_obj, predicate, external_uri]
+        
+        Triannon::LdpCreator.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
+            # we should never get here for external references ...
+          end
+        }
+        true
+      else
+        false
+      end
+    end
+    
+    # if uri_obj has a type of RDF::Content.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] predicate the predicate for [subject_obj, predicate, (ext_url)] statement
+    # to be added to @oa_graph, e.g. RDF::OpenAnnotation.hasTarget
+    # @param [RDF::URI] the subject object to get the predicate statement; defaults to @root_uri
+    # @returns [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]
+      if solns.count > 0
+        blank_node = RDF::Node.new
+        @oa_graph << [subject_obj, predicate, blank_node]
+        
+        Triannon::LdpCreator.subject_statements(uri_obj, @ldp_anno_graph).each { |stmt|
+          if stmt.subject == uri_obj
+            @oa_graph << [blank_node, stmt.predicate, stmt.object]
+          else
+            # it is a descendant statment - take as is
+            @oa_graph << stmt
+          end
+        }
+        true
+      else
+        false
+      end
+    end
+    
+    # if uri_obj has a type of RDF::OpenAnnotation.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] predicate the predicate for [@root_uri, predicate, (sel_res)] statement
+    # to be added to @oa_graph, e.g. RDF::OpenAnnotation.hasTarget
+    # @returns [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]
+      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::LdpCreator.subject_statements(uri_obj, @ldp_anno_graph)
+        specific_res_stmts.each { |stmt|
+          if stmt.predicate == RDF::OpenAnnotation.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
+            end
+          elsif stmt.predicate == RDF::OpenAnnotation.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, 
+            # 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]
+          end
+        }
+        
+        # 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| 
+          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
+            if selector_blank_node && stmt.subject == selector_obj
+              @oa_graph << [selector_blank_node, stmt.predicate, stmt.object]
+            end
+          # there shouldn't be any other statements present
+          end
+        }
+        true
+      else
+        false
+      end
+    end
+
+    # if uri_obj has a type of RDF::OpenAnnotation.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] predicate the predicate for [@root_uri, predicate, (choice)] statement
+    # to be added to @oa_graph, e.g. RDF::OpenAnnotation.hasTarget
+    # @returns [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]
+      if solns.count > 0
+        blank_node = RDF::Node.new
+        @oa_graph << [@root_uri, predicate, blank_node]
+        
+        default_obj = nil
+        item_objs = []
+        choice_stmts = Triannon::LdpCreator.subject_statements(uri_obj, @ldp_anno_graph)
+        choice_stmts.each { |stmt|
+          if stmt.predicate == RDF::OpenAnnotation.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)
+            end
+          elsif stmt.predicate == RDF::OpenAnnotation.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)
+            end
+          end
+        }
+        
+        # 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| 
+          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
+          end
+        }
+        true
+      else
+        false
+      end
+    end
 
   end
 

data/app/views/triannon/annotations/_form.html.erb

@@ -13,7 +13,7 @@
 
   <div class="field">
     <%= f.label 'data (as json-ld or turtle)' %><br>
-    <%= f.text_area :data %>
+    <%= f.text_area :data, size: "80x20" %>
   </div>
   <div class="actions">
     <%= f.submit %>

data/lib/triannon.rb

@@ -8,6 +8,7 @@ require 'faraday'
 
 module Triannon
   require "triannon/engine"
+  require "triannon/error"
 
   class << self
     attr_accessor :config

data/lib/triannon/error.rb

@@ -0,0 +1,9 @@
+module Triannon
+  # generic Triannon error allowing rescue to catch all Triannon exceptions
+  class Error < RuntimeError
+  end
+  
+  class ExternalReferenceError < Triannon::Error
+  end
+  
+end

data/lib/triannon/version.rb

@@ -1,3 +1,3 @@
 module Triannon
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: triannon
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Chris Beer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-29 00:00:00.000000000 Z
+date: 2014-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -221,6 +221,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - cabeer@stanford.edu
@@ -241,6 +255,7 @@ files:
 - app/helpers/triannon/application_helper.rb
 - app/models/triannon/annotation.rb
 - app/models/triannon/annotation_ldp.rb
+- app/models/triannon/graph_validator.rb
 - app/services/triannon/ldp_creator.rb
 - app/services/triannon/ldp_destroyer.rb
 - app/services/triannon/ldp_loader.rb
@@ -261,6 +276,7 @@ files:
 - lib/tasks/triannon_tasks.rake
 - lib/triannon.rb
 - lib/triannon/engine.rb
+- lib/triannon/error.rb
 - lib/triannon/oa_context_20130208.json
 - lib/triannon/version.rb
 homepage: 
@@ -283,7 +299,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Rails engine for working with storage of OpenAnnotations stored in Fedora4