krikri 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fc07861777f021a9d02ccb7c9be507cd7f8681d
-  data.tar.gz: 894be25e402c7aea81b7f82708ee8971e86bf97f
+  metadata.gz: 5aa4fcca719417b8f265da3ee528f69d5fcbc3ec
+  data.tar.gz: d505e82b5881a9fae1e3f65b85b19157a6083bae
 SHA512:
-  metadata.gz: e9ef1dc88f88c4ac8e2ae167758549309c79b0332a29bad230d199fcc9518c03c07832900a51eed2e497b7283b1725c113c6e4080ee805303a7b1bb26370f7d5
-  data.tar.gz: 26b4f8a38a3bf313e8b2fce1a35474feb3fd19b6fe401817f05f98948b4ac99dae8d466134ae1c31f163facd1c7add886a5e8d67ab1d110659f5398f754efabe
+  metadata.gz: 197ad8e9e763ce9abb331dc57b9bca7a12103484107f6b27002adc946a8a5244eb27b1756e5dbf8e37881977a59a0ba541639c5485ed9ff11f55f3453362902f
+  data.tar.gz: 0c328d43f14401964ec57725850d813cf50892b6c11f3e71fc74c2fa318b8b96c83a8eec8dde3542211b9d70787eb6322ae8c7d4ddac8bee916fee6adf8aaca3

data/app/models/krikri/original_record.rb

@@ -3,6 +3,7 @@ module Krikri
   # Handles records as harvested, prior to mapping
   class OriginalRecord
     include Krikri::LDP::Resource
+    include Krikri::LDP::Invalidatable
 
     attr_accessor :content, :local_name, :rdf_subject
     attr_writer :content_type

data/lib/krikri/async_uri_getter.rb

@@ -0,0 +1,127 @@
+require 'faraday'
+require 'faraday_middleware'
+
+require 'net/http'
+require 'thread'
+require 'uri'
+
+module Krikri
+  ##
+  # Helper class for fetching multiple URLs concurrently. 
+  #
+  # @example to fetch 5 URLs in 5 threads
+  #    urls = ['http://example.com/one',
+  #            'http://example.com/two',
+  #            'http://example.com/three',
+  #            'http://example.com/four',
+  #            'http://example.com/five']
+  #           .map { |url| URI.parse(url) }
+  #
+  #    getter = Krikri::AsyncUriGetter.new
+  #
+  #    requests = urls.map do |url|
+  #      getter.add_request(uri: url, opts: { follow_redirects: true })
+  #    end
+  #    
+  # At this point, 5 threads are launched to fetch the list of URLs.  We can
+  # wait for them all to finish if we want to make sure we don't continue until
+  # all threads have terminated: `requests.map(&:join)`
+  #
+  # Or simply access the responses and have our current thread block until
+  # they're available:
+  #
+  #    requests.each do |request|
+  #      request.with_response do |response|
+  #        if response.status == 200
+  #          puts "Response body: #{response.body}"
+  #        else
+  #          puts "Got return status: #{response.status}"
+  #        end
+  #      end
+  #    end
+  #
+  class AsyncUriGetter
+    MAX_REDIRECTS = 10
+
+    ##
+    # Create a new asynchronous URL fetcher.
+    #
+    # @param opts [Hash] a hash of the supported options, which are:
+    # @option opts [Boolean] :follow_redirects  Whether to follow HTTP 3xx
+    #   redirects.
+    # @option opts [Integer] :max_redirects Number of redirects to follow before
+    #   giving up. (default: 10)
+    def initialize(opts: {})
+      @default_opts = { max_redirects: MAX_REDIRECTS }.merge(opts)
+    end
+
+    ##
+    # Run a request (in a new thread) and return a promise-like object for the
+    # response.
+    #
+    # @param uri [URI] the URI to be fetched
+    # @param headers [Hash<String, String>] HTTP headers to include with the
+    #   request
+    # @param opts [Hash] options to override the ones provided when
+    #   AsyncUriGetter was initialized. All supported options from `#initialize`
+    #   are available here as well.
+    def add_request(uri: nil, headers: {}, opts: {})
+      fail ArgumentError, "uri must be a URI; got: #{uri}" unless uri.is_a?(URI)
+      Request.new(uri, headers, @default_opts.merge(opts))
+    end
+
+    Request = Struct.new(:uri, :headers, :opts) do
+      def initialize(*)
+        super
+        @request_thread = start_request
+      end
+
+      ##
+      # Wait for the request thread to complete
+      def join
+        @request_thread.join
+      end
+
+      ##
+      # @yield [Faraday::Response] the response returned for the request
+      def with_response
+        yield @request_thread.value
+      end
+
+      private
+
+      ##
+      # Run the Faraday request in a new thread
+      def start_request
+        Thread.new do
+          http.get(uri) do |request|
+            headers.each { |header, val| request.headers[header.to_s] = val }
+          end
+        end
+      end
+
+      ##
+      # @return [Faraday::Connection] a connection with sensible defaults
+      def http
+        @http ||= Faraday.new do |conn|
+          conn.request :retry,
+                       max: 4,
+                       interval: 0.025,
+                       interval_randomness: 0.5,
+                       backoff_factor: 2,
+                       exceptions: [Faraday::ConnectionFailed,
+                                    'Errno::ETIMEDOUT',
+                                    'Timeout::Error',
+                                    'Error::TimeoutError',
+                                    Faraday::TimeoutError]
+          if opts.fetch(:follow_redirects, false)
+            conn.use(FaradayMiddleware::FollowRedirects,
+                     limit: opts.fetch(:max_redirects))
+          end
+
+          conn.adapter Faraday.default_adapter
+        end
+      end
+    end
+  end
+end

data/lib/krikri/engine.rb

@@ -83,6 +83,12 @@ module Krikri
     end
 
     initializer :aggregation do
+      class NamespaceError < RuntimeError
+        def initialize(uri)
+          super("Tried to get DPLA ID for non-DPLA URI #{uri}")
+        end
+      end
+
       DPLA::MAP::Aggregation.class_eval do
         include Krikri::MapCrosswalk
         include Krikri::LDP::RdfSource
@@ -124,6 +130,18 @@ module Krikri
             .to_s)
         end
 
+        ##
+        # @return [String, nil] returns only the final portion of the URI (the 
+        #   "local name"), with the `#base_uri` removed. `nil` if this is a node
+        #
+        # @raise NamespaceError
+        def dpla_id
+          return nil if node?
+          raise NamespaceError, rdf_subject unless id.start_with?(base_uri)
+
+          id.gsub("#{base_uri}/", '')
+        end
+          
         private
 
         def local_name_from_original_record

data/lib/krikri/ldp.rb

@@ -4,7 +4,8 @@ module Krikri
   # As LDP support develops, it might be possible to excract this or replace it
   # with a tool like the `ldp` gem.
   module LDP
-    autoload :Resource,     'krikri/ldp/resource'
-    autoload :RdfSource,    'krikri/ldp/rdf_source'
+    autoload :Resource,         'krikri/ldp/resource'
+    autoload :RdfSource,        'krikri/ldp/rdf_source'
+    autoload :Invalidatable,    'krikri/ldp/invalidatable'
   end
 end

data/lib/krikri/ldp/invalidatable.rb

@@ -0,0 +1,107 @@
+module Krikri::LDP
+  ##
+  # Implements invalidation for `Krikri::LDP::Resource`s. This is different 
+  # from deletion, in that the resource continues to respond `200 OK`, and 
+  # return the representation, Nothing is removed from the LDP server.
+  # 
+  # Works as a mixin to `Krikri::LDP::Resource`, assuming an implementation of
+  # `#rdf_source`, which may simply return `self`.
+  #
+  # @example invalidating a resource
+  #   class MyResource
+  #     include Krikri::LDP::Resource
+  #     include Krikri::LDP::Invalidatable
+  #
+  #     def rdf_subject
+  #       @rdf_subject ||= RDF::URI('http://example.com/ldp/a/resource/path')
+  #     end
+  #   end
+  #  
+  #   invalidatable_resource = MyResource.new
+  #   # the resource must exist before it can be invalidated! 
+  #   invalidatable_resource.save
+  #
+  #   invalidatable_resource.invalidate!
+  #   invalidatable_resource.invalidated? # => true
+  #   invalidatable_resource.invalidated_at_time 
+  #   # => Thu, 03 Dec 2015 10:27:45 -0800
+  #
+  # @see http://www.w3.org/TR/2013/REC-prov-dm-20130430/#term-Invalidation 
+  #   for documentation on PROV invalidation
+  module Invalidatable
+    # @see RDF::PROV
+    INVALIDATED_BY_URI = RDF::PROV.wasInvalidatedBy
+    INVALIDATED_TIME_URI = RDF::PROV.invalidatedAtTime
+
+    ##
+    # Invalidates the resource by marking it with a `prov:invalidatedAtTime`. If
+    # an `RDF::Term` is passed as the first argument, that term is used as the 
+    # value of `prov:wasInvalidatedBy`.
+    #
+    # @example invalidating with an activity
+    #   invalidatable_resource.invalidate!(RDF::URI('http://example.org/moomin'))
+    #   invalidatable_resource.was_invalidated_by
+    #   # => #<RDF::URI:0x2acab846109c URI:http://example.org/moomin>
+    #
+    # @param activity_uri [RDF::Term] a URI for the invalidating activity. If 
+    #   none is given, this defaults to `nil` and no `prov:wasInvalidatedBy`
+    #   statement is added.
+    # @param ignore_invalid [Boolean] if true, supresses errors on already,
+    #   invalid records
+    #
+    # @raise [RuntimeError] when the resource does not exist or is already 
+    #   invalid; unless `ignore_invalid` is `true`
+    # @return [void]
+    def invalidate!(activity_uri = nil, ignore_invalid = false)
+      raise "Cannot invalidate #{rdf_subject}, does not exist." unless exists?
+
+      # force a reload unless we have cached an invalidatedAtTime
+      rdf_source.get({}, true) unless invalidated?
+      # we check invalidated again in case the reload came back invalid
+      if invalidated?
+        return if ignore_invalid
+        raise "Cannot invalidate #{rdf_subject}, already invalid." 
+      end
+
+      uri = RDF::URI(rdf_subject)
+      
+      rdf_source << [uri, INVALIDATED_BY_URI, activity_uri] unless 
+        activity_uri.nil?
+      rdf_source << [uri, INVALIDATED_TIME_URI, DateTime.now]
+
+      rdf_source.save
+    end
+
+    ##
+    # @return [Boolean] `true` if the resource has been marked invalidated.
+    def invalidated?
+      !invalidated_at_time.nil?
+    end
+
+    ##
+    # @return [DateTime, nil] the time this resource was marked invalidated;
+    #   gives `nil` if the resource has not been invalidated.
+    # 
+    # @note if two invalidatedAtTimes exist, we may get either of them back!
+    def invalidated_at_time
+      time = first_property(INVALIDATED_TIME_URI)
+      time.nil? ? nil : time.object
+    end
+
+    ##
+    # @return [RDF::URI, nil] the activity responsible for invalidating the 
+    #   resource
+    # 
+    # @note if two wasInvalidatedBys exist, we may get either of them back!
+    def was_invalidated_by
+      first_property(INVALIDATED_BY_URI)
+    end
+
+    private 
+    
+    def first_property(predicate)
+      res = rdf_source.query([RDF::URI(rdf_subject), predicate, nil])
+      res.empty? ? nil : res.first.object
+    end
+  end
+end

data/lib/krikri/ldp/rdf_source.rb

@@ -7,13 +7,26 @@ module Krikri::LDP
   module RdfSource
     extend ActiveSupport::Concern
     include Krikri::LDP::Resource
+    include Krikri::LDP::Invalidatable
+
+    GENERATED_URI        = RDF::PROV.wasGeneratedBy
+    REVISED_URI          = RDF::DPLA.wasRevisedBy
+
+    ##
+    # @return [Boolean] false if this resource does not ex
+    # @see Krikri::LDP::Resource#exists?
+    def exists?
+      return false if node?
+      super
+    end
+    alias_method :exist?, :exists?
 
     ##
     # PUTs the LDP resource named in #rdf_subject, populating it's content
     # (graph) from the object's RDF::Graph.
     #
     # @see Krikri::LDP::Resource#save
-    # @note this may leave the resource's graph out of sync with the LDP 
+    # @note this may leave the resource's graph out of sync with the LDP
     #   endpoint since the endpoint may add management triples when saving.
     def save(*)
       result = super(dump(:ttl))
@@ -21,14 +34,14 @@ module Krikri::LDP
     end
 
     ##
-    # Saves and forces reload. This updates the graph with any management 
+    # Saves and forces reload. This updates the graph with any management
     # triples added by the LDP endpoint.
     #
     # @see #save
     def save_and_reload(*args)
       result = save(*args)
       get({}, true)
-      result 
+      result
     end
 
     ##
@@ -42,6 +55,12 @@ module Krikri::LDP
       result
     end
 
+    ##
+    # @return [self]
+    def rdf_source
+      self
+    end
+
     ##
     # Adds an appropritate provenance statement with the given URI and saves
     # the resource.
@@ -64,8 +83,7 @@ module Krikri::LDP
     # @see http://www.w3.org/TR/prov-primer/
     # @see http://www.w3.org/TR/2013/REC-prov-o-20130430/
     def save_with_provenance(activity_uri)
-      predicate =
-        exists? ? RDF::DPLA.wasRevisedBy : RDF::PROV.wasGeneratedBy
+      predicate = exists? ? REVISED_URI : GENERATED_URI
       self << RDF::Statement(self, predicate, activity_uri)
       save
     end
@@ -75,7 +93,7 @@ module Krikri::LDP
     ##
     # Clears the RDF::Graph and repopulates it from the http body. Forces text
     # encoding to UTF-8 before passing to the `RDF::Reader`.
-    # 
+    #
     # @return [void]
     #
     # @see http://www.w3.org/TR/turtle/#sec-mime for info about Turtle encoding

data/lib/krikri/ldp/resource.rb

@@ -3,7 +3,28 @@ require 'faraday_middleware'
 
 module Krikri::LDP
   ##
-  # Implements basic LDP CRUD operations
+  # Implements basic LDP CRUD operations. Requires an implementation of 
+  # `#rdf_subject` returning an `RDF::URI`. The resource idenitified by the URI
+  # must conform to LDP Resource's interaction patterns. 
+  #
+  # @example implementing a resource
+  #   class MyResource
+  #     include Krikri::LDP::Resource
+  #
+  #     def rdf_subject
+  #       @rdf_subject ||= RDF::URI('http://example.com/ldp/a/resource/path')
+  #     end
+  #   end
+  #
+  # @note Ideally, this is a general purpose LDP resource. However some HTTP 
+  #   PUT creation behavior may be specific to Marmotta. This avoids the need to
+  #   interact directly with the owning container, but is a less generalized 
+  #   implementation.
+  #
+  # @see http://www.w3.org/TR/ldp/#h-ldpr-resource LDP Resource interaction 
+  #   patterns.
+  # @see https://wiki.apache.org/marmotta/LDPImplementationReport for 
+  #   information about Marmotta's PUT.
   module Resource
     extend ActiveSupport::Concern
 

data/lib/krikri/map_crosswalk.rb

@@ -134,7 +134,6 @@ module Krikri
 
         set_value(sr, :relation, parent_sr.relation)
         set_value(sr, :rights, parent_sr.rights, true)
-        set_value(sr, :temporal, parent_sr.temporal)
         set_value(sr, :title, parent_sr.title)
 
         set_value(sr, :collection, parent_sr.collection) do |coll|
@@ -149,6 +148,10 @@ module Krikri
           build_time_span(date)
         end
 
+        set_value(sr, :temporal, parent_sr.temporal) do |temporal|
+          build_time_span(temporal)
+        end
+
         set_value(sr, :spatial, parent_sr.spatial) do |place|
           build_place(place)
         end
@@ -173,7 +176,7 @@ module Krikri
       def build_time_span(source)
         return unless source.is_a? DPLA::MAP::TimeSpan
         date = {}
-        date[:displayDate]
+        set_value(date, :displayDate, source.prefLabel, true, &:as_json)
         set_value(date, :begin, source.begin, true, &:as_json)
         set_value(date, :end, source.end, true, &:as_json)
 

data/lib/krikri/version.rb

@@ -1,3 +1,3 @@
 module Krikri
-  VERSION = '0.10.1'.freeze
+  VERSION = '0.11.0'.freeze
 end

data/spec/internal/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /home/tjohnson/src/dpla/krikri
   specs:
-    krikri (0.10.0)
+    krikri (0.10.1)
       analysand (= 4.0.0)
       audumbla (~> 0.1)
       blacklight (~> 5.8.0)
@@ -152,8 +152,8 @@ GEM
       domain_name (~> 0.5)
     http_parser.rb (0.6.0)
     i18n (0.7.0)
-    jbuilder (2.3.2)
-      activesupport (>= 3.0.0, < 5)
+    jbuilder (2.4.0)
+      activesupport (>= 3.0.0, < 5.1)
       multi_json (~> 1.2)
     jettywrapper (2.0.3)
       activesupport (>= 3.0.0)
@@ -242,7 +242,7 @@ GEM
       activesupport (= 4.1.6)
       rake (>= 0.8.7)
       thor (>= 0.18.1, < 2.0)
-    rake (10.4.2)
+    rake (10.5.0)
     rdf (1.1.17.1)
       link_header (~> 0.0, >= 0.0.8)
     rdf-aggregate-repo (1.1.0.1)