triannon 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c88a5ccc4b645bbb52d89183ed8fa42f49eda50
-  data.tar.gz: eb58660e72be33aa86bc66f0feb676d9cf2ed4ea
+  metadata.gz: 9936254da42efbcc7d7225b4f684097a2ac84f0f
+  data.tar.gz: b0d8e6bcba4019fc9cef4300f484f7a2d11774db
 SHA512:
-  metadata.gz: 54bc08d30db5e0fd1a4e1a93d70ed2da19a3359586c3f1c995b7a5713a5c30635736443193f18ec327db3a21eca3b9b3ee65deb5e59034bd57417960e1ec6710
-  data.tar.gz: 5f9f0fa5b0384791e765719c989996782786bcfb019e90b62c31b84d0fe39cdb42d82198dc4fe750f36f8af4c5f0e5f10a0ce928ae4a85d06335c83bea1a96f5
+  metadata.gz: 90a6538ea8c10582a4e06f1e159947b1013784d7f2b7c8474811f13534f3c4806ed559b2456b304c5d51ce688d0b5f2ff44b2a43b518a181827fd3a32b3276bc
+  data.tar.gz: efda4aab06e7a5939d44e61ab6a860be835b20301c2f699291b1b246ae59e3820563720860c0ef307fbb1b9d4447b695ed911fbd7534df4f16419f77a2dce349

data/README.md

@@ -2,7 +2,7 @@
 
 # Triannon
 
-Demonstration Open Annotation to support the Linked Data for Libraries use cases.
+Store Open Annotation in Fedora4 to support the Linked Data for Libraries use cases.
 
 ## Tests
 
@@ -32,11 +32,21 @@ Then run the triannon generator:
 $ rails g triannon:install
 ```
 
+Edit the `config/triannon.yml` file:
+
+* `ldp_url:` Points to the root annotations container in 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.
+
 ## Running the application in development
 
 There is a bundled rake task for running the test app:
 
 ```console
+# One time setup: run the following 3 commands
+$ rake jetty:download
+$ rake jetty:unzip
 $ rake engine_cart:generate # (first run only)
+
+# Run the test app
 $ rake triannon:server
 ```

data/Rakefile

@@ -4,7 +4,7 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-ZIP_URL = "https://github.com/projecthydra/hydra-jetty/archive/v8.0.0.rc2.zip"
+ZIP_URL = "https://github.com/sul-dlss/hydra-jetty/archive/fedora-4/edge.zip"
 
 require 'active_support/benchmarkable'
 require 'jettywrapper'
@@ -31,8 +31,8 @@ task :ci => ['engine_cart:generate', 'jetty:clean'] do
 end
 
 namespace :triannon do
-  desc 'run the test rails app w triannon'
-  task :server do
+  desc 'run test rails app w triannon and jetty'
+  task :server_jetty do
     jetty_params = Jettywrapper.load_config.merge({:jetty_home => File.expand_path(File.dirname(__FILE__) + '/jetty')})
     Jettywrapper.wrap(jetty_params) do
       within_test_app do
@@ -41,8 +41,17 @@ namespace :triannon do
     end
   end
 
-  desc 'run the test rails console w triannon'
-  task :console do
+  desc 'run test rails app w triannon but no jetty'
+  task :server_no_jetty do
+    within_test_app do
+      system "rails s"
+    end
+  end
+  desc 'run test rails app w triannon but no jetty'
+  task :server => :server_no_jetty
+
+  desc 'run test rails console w triannon'
+  task :console_jetty do
     jetty_params = Jettywrapper.load_config.merge({:jetty_home => File.expand_path(File.dirname(__FILE__) + '/jetty')})
     Jettywrapper.wrap(jetty_params) do
       within_test_app do
@@ -51,12 +60,15 @@ namespace :triannon do
     end
   end
 
-  desc 'run the test rails console w triannon but no jetty'
+  desc 'run test rails console w triannon but no jetty'
   task :console_no_jetty do
     within_test_app do
       system "rails c"
     end
   end
+  desc 'run test rails console w triannon but no jetty'
+  task :console => :console_no_jetty
+
 end
 
 

data/app/controllers/triannon/annotations_controller.rb

@@ -2,6 +2,7 @@ require_dependency "triannon/application_controller"
 
 module Triannon
   class AnnotationsController < ApplicationController
+    before_action :default_format_jsonld, only: [:show]
     before_action :set_annotation, only: [:show, :edit, :update, :destroy]
 
     # GET /annotations/annotations
@@ -11,6 +12,22 @@ module Triannon
 
     # GET /annotations/annotations/1
     def show
+      respond_to do |format|
+        format.jsonld { render :json => @annotation.graph.to_jsonld }
+        format.ttl {
+          accept_return_type = mime_type_from_accept(["application/x-turtle", "text/turtle"])
+          render :body => @annotation.graph.to_ttl, content_type: accept_return_type if accept_return_type }
+        format.rdfxml {
+          accept_return_type = mime_type_from_accept(["application/rdf+xml", "text/rdf+xml", "text/rdf"])
+          render :body => @annotation.graph.to_rdfxml, content_type: accept_return_type if accept_return_type }
+        format.json {
+          accept_return_type = mime_type_from_accept(["application/json", "text/x-json", "application/jsonrequest"])
+          render :json => @annotation.graph.to_jsonld, content_type: accept_return_type if accept_return_type }
+        format.xml {
+          accept_return_type = mime_type_from_accept(["application/xml", "text/xml", "application/x-xml"])
+          render :xml => @annotation.graph.to_rdfxml, content_type: accept_return_type if accept_return_type }
+        format.html { render :show }
+      end
     end
 
     # GET /annotations/annotations/new
@@ -58,5 +75,25 @@ module Triannon
       def annotation_params
         params.require(:annotation).permit(:data)
       end
+
+      def default_format_jsonld
+        if ((!request.accept || request.accept.empty?) && (!params[:format] || params[:format].empty?))
+          request.format = "jsonld"
+        end
+      end
+
+      # find first mime type from request.accept that matches return mime type
+      def mime_type_from_accept(return_mime_types)
+        @mime_type_from_accept ||= begin
+          if request.accept && request.accept.is_a?(String)
+            accepted_formats = request.accept.split(',')
+            accepted_formats.each { |accepted_format|
+              if return_mime_types.include? accepted_format
+                return accepted_format
+              end
+            }
+          end
+        end
+      end
   end
 end

data/app/models/triannon/annotation.rb

@@ -1,75 +1,94 @@
 module Triannon
-  class Annotation < ActiveRecord::Base
-    
-    validates :data, presence: true,
-                      length: {minimum: 30}
+  class Annotation
+    include ActiveModel::Model
+
+    attr_accessor :id, :data
+
+    validates_each :data do |record, attr, value|
+      record.errors.add attr, 'less than 30 chars' if value.to_s.length < 30
+    end
 
     # full validation should be optional?
     #   minimal:  a subject with the right type and a hasTarget?  (see url)
     # and perhaps modeled on this:
     #   https://github.com/uq-eresearch/lorestore/blob/3e9aa1c69aafd3692c69aa39c64bfdc32b757892/src/main/resources/OAConstraintsSPARQL.json
 
+
+    def persisted?
+      self.id.present?
+    end
+
     def url
       if graph_exists?
-        solution = graph.query(self.class.basic_query)
+        solution = graph.query self.class.anno_query
         if solution && solution.size == 1
           solution.first.s.to_s
         # TODO:  raise exception if no URL?
         end
       end
     end
-    
+
     # FIXME:  this should be part of validation:  RDF.type should be RDF::OpenAnnotation.Annotation
     def type
       if graph_exists?
-        query = RDF::Query.new
-        query << [:s, RDF::OpenAnnotation.hasTarget, nil]
-        query << [:s, RDF.type, :type]
-        solution = graph.query(query)
+        q = RDF::Query.new
+        q << [:s, RDF::OpenAnnotation.hasTarget, nil] # must have a target
+        q << [:s, RDF.type, :type]
+        solution = graph.query q
+        solution.distinct!
         if solution && solution.size == 1
           solution.first.type.to_s
         # TODO:  raise exception if no type?
         end
       end
     end
-    
+
     def has_target
-      # FIXME:  can have multiple targets per spec  (example 8)
       # FIXME:  target might be more than a string (examples 14-17)
-      stmt = rdf.find_all { |s| 
-        s.predicate.to_s == RDF::OpenAnnotation.hasTarget
-      }.first
-      stmt.object.to_str if stmt
+      if graph_exists?
+        q = self.class.anno_query.dup
+        q << [:s, RDF::OpenAnnotation.hasTarget, :target]
+        solution = graph.query q
+        if solution && solution.size > 0
+          targets = []
+          solution.each {|res|
+            targets << res.target.to_s
+          }
+          targets
+        # TODO:  raise exception if none?
+        end
+      end
     end
-    
+
     def has_body
-      # FIXME:  can have multiple bodies per spec
-      stmt = rdf.find_all { |s| 
-        s.predicate.to_s == RDF::OpenAnnotation.hasBody
-      }.first
-      
-      # FIXME:  body can be other things
-      # if body is blank node and has character content, then return it
-      body = stmt.object if stmt
-      if body && body.is_a?(RDF::Node)
-        body_stmts = rdf.find_all { |s| s.subject == body }
-        if body_stmts && 
-            body_stmts.detect { |s| 
-              s.predicate.to_s == RDF.type &&
-              s.object.to_s == RDF::Content.ContentAsText
-            }
-          chars_stmt = body_stmts.detect { |s| s.predicate.to_s == RDF::Content.chars}
-          return chars_stmt.object.to_s if chars_stmt
+      # FIXME:  body can be other things besides blank node with chars
+      bodies = []
+      if graph_exists?
+        q = self.class.anno_query.dup
+        q << [:s, RDF::OpenAnnotation.hasBody, :body]
+        # for chars content
+        # the following two lines are equivalent in identifying inline chars content
+        # q << [:body, RDF.type, RDF::Content.ContentAsText]
+        q << [:body, RDF::Content.chars, :chars]
+        # for non-chars content
+        # // non-embedded Text resource
+        #?body a dctypes:Text ;
+        #  dc:format "application/msword .
+        solution = graph.query q
+        if solution && solution.size > 0
+          solution.each {|res|
+            bodies << res.chars.to_s
+          }
         end
       end
-      nil
+      bodies
     end
 
     def motivated_by
       if graph_exists?
-        q = self.class.basic_query.clone
+        q = self.class.anno_query.dup
         q << [:s, RDF::OpenAnnotation.motivatedBy, :motivated_by]
-        solution = graph.query(q)
+        solution = graph.query q
         if solution && solution.size > 0
           motivations = []
           solution.each {|res|
@@ -81,39 +100,66 @@ module Triannon
       end
     end
 
-    def rdf
-      @rdf ||= JSON::LD::API.toRdf(json_ld) if json_ld
+    def graph
+      @graph ||= data_to_graph
+    end
+
+    def graph= g
+      @graph = g
     end
 
-    def graph
-      g = data_to_graph
-      @graph ||= g if g
-    end
-
-    # query for a subject with 
-    #  predicate  RDF::OpenAnnotation.hasTarget  
-    #  type of RDF::OpenAnnotation.Annotation
-    def self.basic_query
-      @basic_query ||= begin
-        basic_query = RDF::Query.new
-        basic_query << [:s, RDF.type, RDF::URI("http://www.w3.org/ns/oa#Annotation")]
-        basic_query << [:s, RDF::OpenAnnotation.hasTarget, nil]
+    # 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
     end
-    
+
+    def self.create(attrs = {})
+      a = Triannon::Annotation.new attrs
+      a.save
+      a
+    end
+
+    def save
+      # check if valid?
+      graph
+      @key = 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
+    end
+
+    def self.all
+      Triannon::LdpLoader.find_all
+    end
+
+
 private
 
     # loads RDF::Graph from data attribute.  If data is in json-ld, converts it to turtle.
     def data_to_graph
       if data
+        data.strip!
         case data
-          when /\{\s*\"@\w+\"/
-            json ||= JSON.parse(data)
-            g ||= RDF::Graph.new << JSON::LD::API.toRdf(json_ld) if json
+          when /\A\{.+\}\Z/m
+            g ||= RDF::Graph.new << JSON::LD::API.toRdf(json_ld) if json_ld
             self.data = g.dump(:ttl) if g
-          #when /http/
-          #  g ||= RDF::Graph.load(data, :format => :ttl)
-          else # assume turtle
+          when /\A<.+>\Z/m # (Note:  \A and \Z and m are needed instead of ^$ due to \n in data)
+            g = RDF::Graph.new
+            g.from_rdfxml(data)
+            g = nil if g.size == 0
+          when /\.\Z/ #  (Note:  \Z is needed instead of $ due to \n in data)
+            # turtle ends in period
             g = RDF::Graph.new
             g.from_ttl(data)
             g = nil if g.size == 0
@@ -123,9 +169,18 @@ private
     end
 
     def json_ld
+      if data.match(/"@context"\s*\:\s*"http\:\/\/www\.w3\.org\/ns\/oa-context-20130208\.json"/)
+        data.sub!("\"http://www.w3.org/ns/oa-context-20130208.json\"", json_oa_context)
+      elsif data.match(/"@context"\s*\:\s*"http\:\/\/www\.w3\.org\/ns\/oa\.jsonld"/)
+        data.sub!("\"http://www.w3.org/ns/oa.jsonld\"", json_oa_context)
+      end
       @json_ld ||= JSON.parse(data) rescue nil
     end
-    
+
+    def json_oa_context
+      @json_oa_context ||= File.read("lib/triannon/oa_context_20130208.json")
+    end
+
     def graph_exists?
       graph && graph.size > 0
     end

data/app/models/triannon/annotation_ldp.rb

@@ -0,0 +1,54 @@
+module Triannon
+  class AnnotationLdp
+
+    # RDF::Graph object with all triples, including back end (e.g. LDP, Fedora)
+    def graph
+      @g ||= RDF::Graph.new
+    end
+
+    # 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
+    end
+
+    def base_uri
+      res = graph.query anno_query
+      res.first.s
+    end
+
+    def body_uris
+      q = anno_query
+      q << [:s, RDF::OpenAnnotation.hasBody, :body_uri]
+      solns = graph.query q
+      result = []
+      solns.distinct.each { |soln| 
+        result << soln.body_uri 
+      }
+      result
+    end
+
+    def target_uris
+      q = anno_query
+      q << [:s, RDF::OpenAnnotation.hasTarget, :target_uri]
+      solns = graph.query q
+      result = []
+      solns.distinct.each { |soln| 
+        result << soln.target_uri 
+      }
+      result
+    end
+
+    def load_data_into_graph ttl
+      graph.from_ttl ttl
+    end
+
+private
+    def anno_query
+      q = RDF::Query.new
+      q << [:s, RDF.type, RDF::OpenAnnotation.Annotation]
+    end
+
+  end
+end