triannon 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2ebd733067b7971cd2548562f807c5feed3dc31
-  data.tar.gz: 6809922b340468bc2201c67d7f4c45656a24ffad
+  metadata.gz: 4bc729d85bad88af4e64d97bb59bcb387cf24bcd
+  data.tar.gz: c64868417a72673f936d3ab09e465bd3027f5b28
 SHA512:
-  metadata.gz: 2701115eac46a00f11d06484c403da5c30c5a4f05bea5188cc2a80b4cdec54e693b0f5bbb15b882f2327e3e1cc494f6a4fd0c3e6c2a842beb3ad48ad1c1a282b
-  data.tar.gz: 808a6fa21bca5e4bf5a5426c3a7860af1a8134dfb58c7cddb76368351017e8b71a876007085805fecdbbf00a165a351cca508c982a96b038f7d99f4cd1553cee
+  metadata.gz: 1bc829a33741ab23ca40e69d981f1701b2ce0556618274f107727dee8403a7481d12cfe3eefb207d761d275ec7dcdbda9cc1f4cb0e488e67617154edd917e544
+  data.tar.gz: 2e8440b488dde0e2dfb9f826979da480552209614cd5150108fb6be57bf17b2f28ca525e387bd4178502e4cfc02e3fe1683bd1e47e07b332fbd3f2f2736ace9c

data/README.md

@@ -44,6 +44,65 @@ Generate the root annotations container on the LDP server
 $ rake triannon:create_root_container
 ```
 
+# Client Interactions with Triannon
+
+### Get a list of annos
+NOTE:  implementation of Annotation Lists is coming!
+GET: http://(host)/
+GET: http://(host)/annotations
+
+### Get a particular anno
+GET: http://(host)/annotations/(anno_id)
+* use HTTP Accept header with mime type to indicate desired format
+** default:  jsonld
+*** indicate desired context url in the HTTP Accept header thus:
+**** Accept: application/ld+json; profile="http://www.w3.org/ns/oa-context-20130208.json"
+**** Accept: application/ld+json; profile="http://iiif.io/api/presentation/2/context.json"
+
+** also supports turtle, rdfxml, json, html
+*** indicated desired context url for jsonld as json in the HTTP Link header thus:
+**** Accept: application/json
+**** Link: http://www.w3.org/ns/oa.json; rel="http://www.w3.org/ns/json-ld#context"; type="application/ld+json"
+***** note that the "type" part is optional and refers to the type of the rel, which is the reference for all json-ld contexts.
+** see https://github.com/sul-dlss/triannon/blob/master/app/controllers/triannon/annotations_controller.rb #show method for mime formats accepted
+
+#### JSON-LD context
+You can request IIIF or OA context for jsonld.  
+
+The correct way:
+GET: http://(host)/annotations/(anno_id)
+* use HTTP Accept header with mime type and context url:
+** Accept: application/ld+json; profile="http://www.w3.org/ns/oa-context-20130208.json"
+** Accept: application/ld+json; profile="http://iiif.io/api/presentation/2/context.json"
+
+You can also use either of these methods (with the correct HTTP Accept header):
+
+GET: http://(host)/annotations/iiif/(anno_id)
+GET: http://(host)/annotations/(anno_id)?jsonld_context=iiif
+
+GET: http://(host)/annotations/oa/(anno_id)
+GET: http://(host)/annotations/(anno_id)?jsonld_context=oa
+
+Note that OA (Open Annotation) is the default context if none is specified.
+
+### Create an anno
+POST: http://(host)/annotations
+* the body of the HTTP request should contain the annotation, as jsonld, turtle, or rdfxml
+* the Content-Type header should be the mime type matching the body
+* the anno to be created should NOT already have an assigned @id
+* to get a particular format back, use the HTTP Accept header
+** to get a particular context for jsonld, do one of the following:
+**** Accept: application/ld+json; profile="http://www.w3.org/ns/oa-context-20130208.json"
+**** Accept: application/ld+json; profile="http://iiif.io/api/presentation/2/context.json"
+** to get a particular jsonld context for jsonld as json, specify it in the HTTP Link header thus:
+**** Accept: application/json
+**** Link: http://www.w3.org/ns/oa.json; rel="http://www.w3.org/ns/json-ld#context"; type="application/ld+json"
+***** note that the "type" part is optional and refers to the type of the rel, which is the reference for all json-ld contexts.
+
+### Delete an anno
+DELETE: http://(host)/annotations/(anno_id)
+
+
 ## Running the application in development
 
 There is a bundled rake task for running the test app, but there is some one-time set up.
@@ -57,8 +116,7 @@ $ rake jetty:unzip
 ```
 ##### Set up a Triannon flavored Solr
 ```console
-$ cp config/solr/solr.xml jetty/solr
-$ cp config/solr/triannon-core jetty/solr
+rake triannon:solr_jetty_setup
 ```
 
 ##### Set up a runnable Rails app that uses triannon gem

data/Rakefile

@@ -69,6 +69,12 @@ namespace :triannon do
   desc 'run test rails console w triannon but no jetty'
   task :console => :console_no_jetty
 
+
+  desc "set up triannon solr in test jetty"
+  task :solr_jetty_setup do
+    `cp -r config/solr/triannon-core jetty/solr`
+    `cp config/solr/solr.xml jetty/solr`
+  end
 end
 
 

data/app/controllers/triannon/annotations_controller.rb

@@ -3,7 +3,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]
+    before_action :set_annotation, only: [:show, :update, :destroy]
     rescue_from Triannon::ExternalReferenceError, with: :ext_ref_error
 
     # GET /annotations
@@ -13,8 +13,16 @@ module Triannon
 
     # GET /annotations/1
     def show
+      # TODO:  json.set! "@context", Triannon::JsonldContext::OA_DATED_CONTEXT_URL - would this work?
       respond_to do |format|
-        format.jsonld { render_jsonld_per_context (params[:jsonld_context]) }
+        format.jsonld {
+          context_url = context_url_from_accept ? context_url_from_accept : context_url_from_link
+          if context_url && context_url == Triannon::JsonldContext::IIIF_CONTEXT_URL
+            render_jsonld_per_context("iiif", "application/ld+json")
+          else
+            render_jsonld_per_context(params[:jsonld_context], "application/ld+json")
+          end
+        }
         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 }
@@ -23,7 +31,13 @@ module Triannon
           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_jsonld_per_context(params[:jsonld_context], accept_return_type) }
+          context_url = context_url_from_link ? context_url_from_link : context_url_from_accept
+          if context_url && context_url == Triannon::JsonldContext::IIIF_CONTEXT_URL
+            render_jsonld_per_context("iiif", accept_return_type)
+          else
+            render_jsonld_per_context(params[:jsonld_context], accept_return_type)
+          end
+        }
         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 }
@@ -44,7 +58,9 @@ module Triannon
     # 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"]
+      # see https://github.com/sul-dlss/triannon/issues/90 -- prob just want to fix the form to do a POST
+      #  note that need to check for empty? if HTTP Header Content-Type is json (but not jsonld).
+      if params["annotation"] && !params["annotation"].empty?
         # it's from app html form
         params.require(:annotation).permit(:data)
         if params["annotation"]["data"]
@@ -52,13 +68,43 @@ module Triannon
         end
       else
         # it's a direct post request
-        @annotation = Annotation.new(:data => request.body.read)
+        content_type = request.headers["Content-Type"]
+        @annotation = Annotation.new({:data => request.body.read, :expected_content_type => content_type})
       end
       
       if @annotation.save
-        redirect_to @annotation, status: 201, notice: 'Annotation was successfully created.'
+        default_format_jsonld # NOTE: this must be here and not in before_filter or we get Missing template errors
+        respond_to do |format|
+          format.jsonld {
+            context_url = context_url_from_link ? context_url_from_link : context_url_from_accept
+            if context_url && context_url == Triannon::JsonldContext::IIIF_CONTEXT_URL
+              render :json => @annotation.jsonld_iiif, status: 201, content_type: "application/ld+json", notice: "Annotation #{@annotation.id} was successfully created."
+            else
+              render :json => @annotation.jsonld_oa, status: 201, content_type: "application/ld+json", notice: "Annotation #{@annotation.id} was successfully created."
+            end
+          }
+          format.ttl {
+            accept_return_type = mime_type_from_accept(["application/x-turtle", "text/turtle"])
+            render :body => @annotation.graph.to_ttl, status: 201, notice: "Annotation #{@annotation.id} was successfully created.", 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, status: 201, notice: "Annotation #{@annotation.id} was successfully created.", 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"])
+            context_url = context_url_from_link ? context_url_from_link : context_url_from_accept
+            if context_url && context_url == Triannon::JsonldContext::IIIF_CONTEXT_URL
+              render :json => @annotation.jsonld_iiif, status: 201, notice: "Annotation #{@annotation.id} was successfully created.", content_type: accept_return_type if accept_return_type
+            else
+              render :json => @annotation.jsonld_oa, status: 201, notice: "Annotation #{@annotation.id} was successfully created.", content_type: accept_return_type if accept_return_type
+            end
+          }
+          format.xml {
+            accept_return_type = mime_type_from_accept(["application/xml", "text/xml", "application/x-xml"])
+            render :body => @annotation.graph.to_rdfxml, status: 201, notice: "Annotation #{@annotation.id} was successfully created.", content_type: accept_return_type if accept_return_type }
+          format.html { render :show, location: @annotation, status: 201, content_type: "text/html", notice: "Annotation #{@annotation.id} was successfully created." }
+        end
       else
-        render :new
+        render :new, status: 400
       end
     end
 
@@ -77,62 +123,108 @@ module Triannon
       @annotation.destroy
       redirect_to annotations_url, status: 204, notice: 'Annotation was successfully destroyed.'
     end
+    
+private
 
-    private
-      # Use callbacks to share common setup or constraints between actions.
-      def set_annotation
-        @annotation = Annotation.find(params[:id])
+    def set_annotation
+      @annotation = Annotation.find(params[:id])
+    end
+    
+    # set format to jsonld if it isn't already set
+    def default_format_jsonld
+      if ((!request.accept || request.accept.empty?) && (!params[:format] || params[:format].empty?))
+        request.format = "jsonld"
       end
-      
-      def default_format_jsonld
-        if ((!request.accept || request.accept.empty?) && (!params[:format] || params[:format].empty?))
-          request.format = "jsonld"
+    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)
+          accept_mime_types = request.accept.split(',')
+          accept_mime_types.each { |mime_type|
+            mime_str = mime_type.split("; profile=").first.strip
+            if return_mime_types.include? mime_str
+              return mime_str
+            end
+          }
         end
       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
-            }
+    # parse the Accept HTTP header for the value of profile if it is a request for jsonld or json
+    # e.g. Accept: application/ld+json; profile="http://www.w3.org/ns/oa-context-20130208.json"
+    # @return [String] url for jsonld @context or nil if missing or non-jsonld/json format
+    def context_url_from_accept
+      if request.format == "jsonld" || request.format == "json"
+        accept_str = request.accept
+        if accept_str && accept_str.split("profile=") && accept_str.split("profile=").last
+          context_url = accept_str.split("profile=").last.strip
+          context_url = context_url[1, context_url.size] if context_url.start_with?('"')
+          context_url = context_url[0, context_url.size-1] if context_url.end_with?('"')
+          case context_url
+            when Triannon::JsonldContext::OA_DATED_CONTEXT_URL, 
+              Triannon::JsonldContext::OA_CONTEXT_URL,
+              Triannon::JsonldContext::IIIF_CONTEXT_URL
+              context_url
+            else
+              nil
           end
         end
       end
+    end
 
-      # handle Triannon::ExternalReferenceError
-      def ext_ref_error(exception)
-        render plain: exception.message, status: 403
-      end
-      
-      # render json_ld respecting requested context
-      # @param [String] req_context set to "iiif" or "oa".  Default is OA
-      # @param [String] mime_type the mime type to be set in the Content-Type header of the HTTP response
-      def render_jsonld_per_context (req_context, mime_type=nil)
-        case req_context
-          when "iiif", "IIIF"
-            if mime_type
-              render :json => @annotation.jsonld_iiif, content_type: mime_type
+    # parse the Accept HTTP Link for the value of rel if it is a request for jsonld or json
+    # e.g. Link: http://www.w3.org/ns/oa.json; rel="http://www.w3.org/ns/json-ld#context"; type="application/ld+json"
+    # note that the "type" part is optional
+    # @return [String] url for jsonld @context or nil if missing or non-jsonld/json format
+    def context_url_from_link
+      if request.format == "jsonld" || request.format == "json"
+        link_str = request.headers["Link"]
+        if link_str && link_str.split("; rel=") && link_str.split("; rel=").first
+          context_url = link_str.split("; rel=").first.strip
+          case context_url
+            when Triannon::JsonldContext::OA_DATED_CONTEXT_URL,
+              Triannon::JsonldContext::OA_CONTEXT_URL,
+              Triannon::JsonldContext::IIIF_CONTEXT_URL
+              context_url
             else
-              render :json => @annotation.jsonld_iiif
-            end
-          when "oa", "OA"
-            if mime_type
-              render :json => @annotation.jsonld_oa, content_type: mime_type
-            else
-              render :json => @annotation.jsonld_oa
-            end
+              nil
+          end
+        end
+      end
+    end
+
+    # handle Triannon::ExternalReferenceError
+    def ext_ref_error(exception)
+      render plain: exception.message, status: 403
+    end
+    
+    # render json_ld respecting requested context
+    # @param [String] req_context set to "iiif" or "oa".  Default is oa
+    # @param [String] mime_type the mime type to be set in the Content-Type header of the HTTP response
+    def render_jsonld_per_context (req_context, mime_type=nil)
+      case req_context
+        when "iiif", "IIIF"
+          if mime_type
+            render :json => @annotation.jsonld_iiif, content_type: mime_type
           else
-            if mime_type
-              render :json => @annotation.jsonld_oa, content_type: mime_type
-            else
-              render :json => @annotation.jsonld_oa
-            end
-        end 
+            render :json => @annotation.jsonld_iiif
+          end
+        when "oa", "OA"
+          if mime_type
+            render :json => @annotation.jsonld_oa, content_type: mime_type
+          else
+            render :json => @annotation.jsonld_oa
+          end
+        else
+          if mime_type
+            render :json => @annotation.jsonld_oa, content_type: mime_type
+          else
+            render :json => @annotation.jsonld_oa
+          end
       end
-  end
-end
+    end
+
+  end # class AnnotationsController
+end # module Triannon

data/app/models/triannon/annotation.rb

@@ -6,7 +6,7 @@ module Triannon
     after_save :solr_save
     after_destroy :solr_delete
 
-    attr_accessor :id, :data
+    attr_accessor :id, :data, :expected_content_type
 
     validates_each :data do |record, attr, value|
       record.errors.add attr, 'less than 30 chars' if value.to_s.length < 30
@@ -45,7 +45,7 @@ module Triannon
       _run_save_callbacks do
         # check if valid?
         graph
-        @id = Triannon::LdpWriter.create_anno self
+        @id = Triannon::LdpWriter.create_anno self if graph && graph.size > 2
       end
     end
 
@@ -113,28 +113,69 @@ protected
     
 private
 
-    # loads RDF::Graph from data attribute.  If data is in json-ld, converts it to turtle.
+    # loads RDF::Graph from data attribute.  If data is in json-ld or rdfxml, converts it to turtle.
     def data_to_graph
       if data
         data.strip!
-        case data
-          when /\A\{.+\}\Z/m  # (Note:  \A and \Z and m are needed instead of ^$ due to \n in data)
-            g ||= RDF::Graph.new << JSON::LD::API.toRdf(json_ld) if json_ld
-            self.data = g.dump(:ttl) if g
-          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
+        if expected_content_type
+          case Mime::Type.lookup(expected_content_type).symbol
+            when :jsonld, :json
+              g = jsonld_to_graph
+            when :ttl
+              g = ttl_to_graph
+            when :rdfxml, :xml
+              g = rdfxml_to_graph
+            else
+              g = nil
+          end
+        else # infer the content type from the content itself
+          case data
+            # \A and \Z and m are needed instead of ^$ due to \n in data
+            when /\A\{.+\}\Z/m  
+              g = jsonld_to_graph
+            when /\A<.+>\Z/m
+              g = rdfxml_to_graph
+            when /\.\Z/ # turtle ends in period
+              g = ttl_to_graph
+            else
+              g = nil
+          end
         end
       end
       g
     end
     
+    # create and load an RDF::Graph object from turtle in data attrib
+    # @return [RDF::Graph] populated RDF::Graph object, or nil
+    def ttl_to_graph
+      g = RDF::Graph.new.from_ttl(data)
+      g = nil if g && g.size == 0
+      g
+    end
+
+    # create and load an RDF::Graph object from jsonld in data attrib
+    # SIDE EFFECT: converts data to turtle for LdpWriter
+    # @return [RDF::Graph] populated RDF::Graph object, or nil
+    def jsonld_to_graph
+      # need to do this to avoid external lookup of jsonld context
+      g ||= RDF::Graph.new << JSON::LD::API.toRdf(json_ld) if json_ld
+      g = nil if g && g.size == 0
+      self.data = g.dump(:ttl) if g  # LdpWriter expects ttl
+      g
+    end
+
+    # create and load an RDF::Graph object from rdfxml in data attrib
+    # SIDE EFFECT: converts data to turtle for LdpWriter
+    # @return [RDF::Graph] populated RDF::Graph object, or nil
+    def rdfxml_to_graph
+      g = RDF::Graph.new.from_rdfxml(data)
+      g = nil if g && g.size == 0
+      self.data = g.dump(:ttl) if g  # LdpWriter expects ttl
+      g
+    end
+
+    # avoid external lookup of jsonld context by putting it inline
+    # @return [Hash] the parsed json after the context is put inline
     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\"", Triannon::JsonldContext.oa_context)

data/lib/triannon/graph.rb

@@ -35,9 +35,9 @@ module Triannon
     
     # @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)
+      inline_context = @graph.dump(:jsonld, :context => Triannon::JsonldContext::OA_DATED_CONTEXT_URL)
       hash_from_json = JSON.parse(inline_context)
-      hash_from_json["@context"] = Triannon::JsonldContext::OA_CONTEXT_URL
+      hash_from_json["@context"] = Triannon::JsonldContext::OA_DATED_CONTEXT_URL
       hash_from_json.to_json
     end
     

data/lib/triannon/version.rb

@@ -1,3 +1,3 @@
 module Triannon
-  VERSION = "0.5.3"
+  VERSION = "0.5.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: triannon
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Chris Beer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-10 00:00:00.000000000 Z
+date: 2015-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -315,7 +315,7 @@ files:
 - lib/triannon/version.rb
 homepage: 
 licenses:
-- Apache 2
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []