triannon 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3fb1a2a5664cb23544e3809666e40fbeac50bf7
-  data.tar.gz: 530b85774e11c73ad4ace71448e200babf0e2887
+  metadata.gz: 0a7836e167aa59510f75b69435f06de72d75a4c6
+  data.tar.gz: efc5bc0bff62bfc9347590b2a13c0e144688e2ed
 SHA512:
-  metadata.gz: d053edac7a6da6482140dc9c9eb4fda5ea467f772b1cc94a5fc05f0b866e2b2575d81278db451d6101b4856fa9ed4974b9677df28f26801f7483f7be375cba95
-  data.tar.gz: 88807450e57ec3e5a801b8be3480dee4c4b7f5d2b46401e0abb0cbfdcbcdfa21306933d1d6b0aa521d251602f86df55bb6545e3ed8a9f81bc76323dd2e20d90d
+  metadata.gz: 04a8c245627c35a0c1d099a40c1d71138e25964f91f8f329c36b628beddd13eca016ef86cfccac88ec98b8dde7d280c79d19a869062752e901e01146fa862918
+  data.tar.gz: 67c3f60fa650ddbcaf6763582f1faf634d4b8766d56ebd3ae505894e96397eab2604d578d92bdb57c6f40da794a55398bdbf3047a8cfb26aad18e7cc9fbbd6e9

data/README.md

@@ -2,9 +2,9 @@
 
 # Triannon
 
-Store Open Annotation in Fedora4 to support the Linked Data for Libraries use cases.
+Store Open Annotation RDF in Fedora4 to support the Linked Data for Libraries use cases.
 
-## Installation into Your Rails Application
+## Installation into Your Existing Rails Application
 
 Add this line to your Rails application's Gemfile
 
@@ -12,12 +12,14 @@ Add this line to your Rails application's Gemfile
 gem 'triannon'
 ```
 
-Then execute:
+Then install the gems:
+
 ```console
 $ bundle install
 ```
 
 Then run the triannon generator:
+
 ```console
 $ rails g triannon:install
 ```
@@ -27,16 +29,20 @@ Edit the `config/triannon.yml` file:
 * `ldp:` Properties of LDP server
   * `url:` the baseurl of LDP server
   * `uber_container:` name of an LDP Basic Container holding specific anno containers
-  * `anno_containers:`  (Future: the names of LDP Basic Containers holding individual annos)
+  * `anno_containers:`  (the names of LDP Basic Containers holding individual annos)
 * `solr_url:` Points to the baseurl of Solr instance configured for Triannon
 * `triannon_base_url:` Used as the base url for all annotations hosted by your Triannon server.  Identifiers from the LDP server will be appended to this base-url.  Generally something like "https://your-triannon-rails-box/annotations", as "/annotations" is added to the path by the Triannon gem
 
-Generate the uber root annotations container on your LDP server:
+Generate the root annotations containers on your LDP server:
 
 ```console
-$ rake triannon:create_uber_root_container
+$ rake triannon:create_root_containers
 ```
 
+  This will generate the uber_container and the anno_containers (aka 'root containers') under the uber_container.
+
+  NOTE:  you MUST create the root containers before creating any annotations.  All annotation MUST be created as a child of a root container.
+
 Set up caching for jsonld context documents:
 
 * by using Rack::Cache for RestClient:
@@ -49,9 +55,9 @@ gem 'rack-cache'
 gem 'rest-client-components'
 ```
 
-    * bundle install
+  * bundle install
 
-  * create a  config/initializers/rest_client.rb
+  * create config/initializers/rest_client.rb
 
 ```ruby
 require 'restclient/components'
@@ -78,6 +84,19 @@ Search Parameters:
 * `bodyKeyword` - matches terms in body characters
 * `motivatedBy` - matches fragment part of motivation predicate URI, e.g.  commenting, tagging, painting
 
+* use HTTP `Accept` header with mime type to indicate desired format
+  * default:  jsonld
+    * `Accept`: `application/ld+json`
+  * also supports turtle, rdfxml, json, html
+    * `Accept`: `application/x-turtle`
+
+### Get a list of annos in a particular root container
+as a IIIF Annotation List (see http://iiif.io/api/presentation/2.0/#other-content-resources)
+
+* `GET`: `http://(host)/annotations/(root container name)/search?targetUri=some.url.org`
+
+Search Parameters as above.
+
 * use HTTP `Accept` header with mime type to indicate desired format
   * default:  jsonld
     * `Accept`: `application/ld+json`
@@ -85,7 +104,9 @@ Search Parameters:
     * `Accept`: `application/x-turtle`
 
 ### Get a particular anno
-`GET`: `http://(host)/annotations/(anno_id)`
+`GET`: `http://(host)/annotations/(root container)/(anno_id)`
+
+NOTE:  you may need to URL encode the anno_id (e.g. "6f%2F0e%2F79%2F92%2F6f0e7992-83f5-4f31-8bb7-94a23465fdfb" instead of "6f/0e/79/92/6f0e7992-83f5-4f31-8bb7-94a23465fdfb"), particularly from a web browser.
 
 * use HTTP `Accept` header with mime type to indicate desired format
   * default:  jsonld
@@ -118,7 +139,7 @@ You can also use either of these methods (with the correct HTTP Accept header):
 Note that OA (Open Annotation) is the default context if none is specified.
 
 ### Create an anno
-`POST`: `http://(host)/annotations`
+`POST`: `http://(host)/annotations/(root container)`
 * the body of the HTTP request should contain the annotation, as jsonld, turtle, or rdfxml
   * Wrap the annotation in an object, as such:
   * `{ "commit" => "Create Annotation", "annotation" => { "data" => oa_jsonld } }`
@@ -134,7 +155,9 @@ Note that OA (Open Annotation) is the default context if none is specified.
       * 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)`
+`DELETE`: `http://(host)/annotations/(root container)/(anno_id)`
+
+NOTE:  you may need to URL encode the anno_id (e.g. "6f%2F0e%2F79%2F92%2F6f0e7992-83f5-4f31-8bb7-94a23465fdfb" instead of "6f/0e/79/92/6f0e7992-83f5-4f31-8bb7-94a23465fdfb")
 
 
 # Running This Code in Development
@@ -143,71 +166,64 @@ There is a bundled rake task for running triannon in a test rails application, b
 
 ## One time setup
 
-### Set up a local instance of Fedora4
-```console
-$ rake jetty:download
-$ rake jetty:unzip
-$ rake jetty:environment
-$ rake triannon:jetty_setup
-```
-
-triannon:jetty_setup task does the following:
-* turns off basic authorization in Fedora4
-* sets up a Triannon flavored Solr
-
 ### Set up the testing Rails app that uses triannon gem
+
 ```console
 $ rake engine_cart:generate # (first run only)
 ```
 
-### Start jetty
+### Set up a local instance of Fedora4 and Solr
+
 ```console
-$ rake jetty:start
+$ rake jetty:download
+$ rake jetty:unzip
+$ rake jetty:environment
+$ rake triannon:jetty_config
 ```
 
-Note that jetty can be very sloooooooow to start up with Fedora and Solr.
-
-#### Check if Solr is up
-Go to http://localhost:8983/solr/#/triannon
-or to http://localhost:8983/solr/triannon/select
+triannon:jetty_config task does the following:
+* turns off basic authorization in Fedora4
+* sets up a Triannon flavored Solr core
 
-If all is well, you will not get an error message; the triannon core exists in Solr.  If all is not
-well, try:
+### Start jetty
 
 ```console
-$ rake jetty:stop
-$ rake triannon:jetty_setup
 $ rake jetty:start
 ```
 
-and then check again.
+Note that jetty can be very sloooooooow (a couple of minutes) to start up with Fedora and Solr.
 
+#### Check if Solr and Fedora are up
+Go to 
+* http://localhost:8983/solr/#/triannon - Solr admin GUI page, you should not see any error text in your browser 
+* http://localhost:8983/solr/triannon/select - actual Solr query; should give http status other than 200 if there is a problem
 
-#### Check if Fedora4 is up
-Go to http://localhost:8983/fedora/rest/
+Go to 
+* http://localhost:8983/fedora/rest/ - you should see a fedora object.
 
-If all is well, you will not get an error message.  If all is not well, try:
+If all is not well for Fedora or Solr, try:
 
 ```console
-$ rake jetty:stop
-$ rake jetty:clean
-$ rake triannon:jetty_startup
-$ rake jetty:start
+$ rake triannon:jetty_reset
 ```
 
-and check for Solr and Fedora again.
+This stops jetty, cleans out the jetty directory, recreates it anew from the download, configures jetty for Triannon, and starts jetty.  It may take a long time (a couple of minutes) for jetty to restart.
+
+Then check the Solr and Fedora urls again.
 
-#### Generate uber root annotations container
-After you ensure that Fedora4 is running:
+
+#### Generate root annotations containers in Fedora
+After you ensure that Fedora is running, you need to create the root anno containers using the configuration of test rails app created by engine_cart:
 
 ```console
 $ cd spec/internal
-$ rake triannon:create_uber_root_container
+$ rake triannon:create_root_containers
 $ cd ../..
 ```
 
 #### Configure spec/internal/config/triannon.yml as specified above
-You probably won't need to change this file.
+NOTE:  You probably won't need to change this file - it will work with the jetty setup provided.
+
 ```console
 $ vi spec/internal/config/triannon.yml
 ```
@@ -221,7 +237,7 @@ $ <cntl + C> # to stop Rails application
 $ rake jetty:stop # to stop Fedora and Solr
 ```
 
-The app will be running at localhost:3000
+The app will be running at localhost:3000, with root containers "foo" and "blah" available (and empty).
 
 # Running the Tests
 

data/app/controllers/concerns/rdf_response_formats.rb

@@ -24,11 +24,9 @@ module RdfResponseFormats
     end
   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
+  # 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
@@ -48,12 +46,10 @@ module RdfResponseFormats
     end
   end
 
-  # 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
+  # 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"]

data/app/controllers/triannon/annotations_controller.rb

@@ -5,6 +5,7 @@ module Triannon
     include RdfResponseFormats
 
     rescue_from Triannon::LDPStorageError, with: :ldp_storage_error
+    rescue_from Triannon::LDPContainerError, with: :ldp_container_error
     rescue_from Triannon::ExternalReferenceError, with: :ext_ref_error
     rescue_from Triannon::SearchError, with: :search_error
     before_action :default_format_jsonld, only: [:show]
@@ -12,7 +13,11 @@ module Triannon
 
     # GET /annotations
     def index
-      redirect_to "/search"
+      if params[:anno_root].present?
+        redirect_to "/#{params[:anno_root]}#{search_path}"
+      else
+        redirect_to search_path
+      end
     end
 
     # GET /annotations/1
@@ -29,10 +34,10 @@ module Triannon
         }
         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 }
+          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 }
+          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"])
           context_url = context_url_from_link ? context_url_from_link : context_url_from_accept
@@ -44,7 +49,7 @@ module Triannon
         }
         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 }
+          render xml: @annotation.graph.to_rdfxml, content_type: accept_return_type if accept_return_type }
         format.html { render :show }
       end
     end
@@ -68,12 +73,12 @@ module Triannon
         # it's from app html form
         params.require(:annotation).permit(:data)
         if params["annotation"]["data"]
-          @annotation = Annotation.new({:data => params["annotation"]["data"]})
+          @annotation = Annotation.new(data: params["annotation"]["data"], root_container: params[:anno_root])
         end
       else
         # it's a direct post request
         content_type = request.headers["Content-Type"]
-        @annotation = Annotation.new({:data => request.body.read, :expected_content_type => content_type})
+        @annotation = Annotation.new(data: request.body.read, expected_content_type: content_type, root_container: params[:anno_root])
       end
 
       if @annotation.save
@@ -83,30 +88,30 @@ module Triannon
           format.jsonld {
             context_url = context_url_from_link ? context_url_from_link : context_url_from_accept
             if context_url && context_url == OA::Graph::IIIF_CONTEXT_URL
-              render :json => @annotation.jsonld_iiif, status: 201, content_type: "application/ld+json"
+              render json: @annotation.jsonld_iiif, status: 201, content_type: "application/ld+json"
             else
-              render :json => @annotation.jsonld_oa, status: 201, content_type: "application/ld+json"
+              render json: @annotation.jsonld_oa, status: 201, content_type: "application/ld+json"
             end
           }
           format.ttl {
             accept_return_type = mime_type_from_accept(["application/x-turtle", "text/turtle"])
-            render :body => @annotation.graph.to_ttl, status: 201, content_type: accept_return_type if accept_return_type }
+            render body: @annotation.graph.to_ttl, status: 201, 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, content_type: accept_return_type if accept_return_type }
+            render body: @annotation.graph.to_rdfxml, status: 201, 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 == OA::Graph::IIIF_CONTEXT_URL
-              render :json => @annotation.jsonld_iiif, status: 201, content_type: accept_return_type if accept_return_type
+              render json: @annotation.jsonld_iiif, status: 201, content_type: accept_return_type if accept_return_type
             else
-              render :json => @annotation.jsonld_oa, status: 201, content_type: accept_return_type if accept_return_type
+              render json: @annotation.jsonld_oa, status: 201, 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, content_type: accept_return_type if accept_return_type }
-          format.html { redirect_to @annotation }
+            render body: @annotation.graph.to_rdfxml, status: 201, content_type: accept_return_type if accept_return_type }
+          format.html { redirect_to annotations_path(anno_root: params[:anno_root], id: @annotation.id) }
         end
       else
         render :new, status: 400
@@ -126,13 +131,13 @@ module Triannon
     # DELETE /annotations/1
     def destroy
       @annotation.destroy
-      redirect_to annotations_url, status: 204, notice: 'Annotation was successfully destroyed.'
+      redirect_to annotations_path(anno_root: params[:anno_root]), status: 204, notice: 'Annotation was successfully destroyed.'
     end
 
 private
 
     def set_annotation
-      @annotation = Annotation.find(params[:id])
+      @annotation = Annotation.find(params[:anno_root], params[:id])
     end
 
     # render Triannon::ExternalReferenceError
@@ -140,14 +145,19 @@ private
       render plain: err.message, status: 403
     end
 
+    # render Triannon::LDPContainer error
+    def ldp_container_error(err)
+      render plain: err.message, status: 403
+    end
+
     # render Triannon::LDPStorage error
     def ldp_storage_error(err)
-      render :body => "<h2>#{err.message}</h2>" + err.ldp_resp_body, status: err.ldp_resp_status, content_type: "text/html"
+      render body: "<h2>#{err.message}</h2>" + err.ldp_resp_body, status: err.ldp_resp_status, content_type: "text/html"
     end
 
     # render Triannon::SearchError
     def search_error(err)
-      render :body => "<h2>#{err.message}</h2>" + (err.search_resp_body ? err.search_resp_body : ""),
+      render body: "<h2>#{err.message}</h2>" + (err.search_resp_body ? err.search_resp_body : ""),
         status: err.search_resp_status ? err.search_resp_status : 400,
         content_type: "text/html"
     end
@@ -159,21 +169,21 @@ private
       case req_context
         when "iiif", "IIIF"
           if mime_type
-            render :json => @annotation.jsonld_iiif, content_type: mime_type
+            render json: @annotation.jsonld_iiif, content_type: mime_type
           else
-            render :json => @annotation.jsonld_iiif
+            render json: @annotation.jsonld_iiif
           end
         when "oa", "OA"
           if mime_type
-            render :json => @annotation.jsonld_oa, content_type: mime_type
+            render json: @annotation.jsonld_oa, content_type: mime_type
           else
-            render :json => @annotation.jsonld_oa
+            render json: @annotation.jsonld_oa
           end
         else
           if mime_type
-            render :json => @annotation.jsonld_oa, content_type: mime_type
+            render json: @annotation.jsonld_oa, content_type: mime_type
           else
-            render :json => @annotation.jsonld_oa
+            render json: @annotation.jsonld_oa
           end
       end
     end

data/app/models/triannon/annotation.rb

@@ -6,11 +6,11 @@ module Triannon
     after_save :solr_save
     after_destroy :solr_delete
 
-    attr_accessor :id, :data, :expected_content_type
+    attr_accessor :id, :data, :expected_content_type, :root_container
 
-    validates_each :data do |record, attr, value|
-      record.errors.add attr, 'less than 30 chars' if value.to_s.length < 30
-    end
+    validates :data, :root_container, presence: true
+    # TODO:  ensure root container exists in LDP store??  seems too expensive
+    validates :data, length: {minimum: 30}
 
     # full validation should be optional?
     #   minimal:  a subject with the right type and a hasTarget?  (see url)
@@ -26,36 +26,33 @@ module Triannon
       a
     end
 
+    # @param [String] root_container - LDP parent container for annotation
     # @param [String] id the unique id of the annotation.  Can include base_uri prefix or omit it.
-    def self.find(id)
-      oa_graph = Triannon::LdpLoader.load id
+    def self.find(root_container, id)
+      oa_graph = Triannon::LdpLoader.load(root_container, id)
       anno = Triannon::Annotation.new
       anno.graph = oa_graph
       anno.id = id
+      anno.root_container = root_container
       anno
     end
 
-    # @deprecated - was used by old annotations#index action, before redirect to search (2015-04)
-    def self.all
-      Triannon::LdpLoader.find_all
-    end
-
     # Instance Methods ----------------------------------------------------------------
 
     def save
       _run_save_callbacks do
         # TODO: check if valid anno?
-        @id = Triannon::LdpWriter.create_anno self if graph && graph.size > 2
+        @id = Triannon::LdpWriter.create_anno(self, root_container) if graph && graph.size > 2
         # reload from storage to get the anno id within the graph
         # TODO:  do graph manipulation to add id instead?
-        @graph = Triannon::LdpLoader.load id
+        @graph = Triannon::LdpLoader.load(root_container, id)
         id
       end
     end
 
     def destroy
       _run_destroy_callbacks do
-        Triannon::LdpWriter.delete_anno @id
+        Triannon::LdpWriter.delete_anno "#{root_container}/#{id}"
       end
     end
 
@@ -103,12 +100,12 @@ protected
 
     # Add annotation to Solr as a Solr document
     def solr_save
-      solr_writer.write(graph) if id_as_url && !id_as_url.empty?
+      solr_writer.write(graph, root_container) if id_as_url.present?
     end
 
     # Delete annotation from Solr
     def solr_delete
-      solr_writer.delete(id) if id
+      solr_writer.delete("#{root_container}/#{id}") if id.present?
     end
 
 private