valkyrie 2.1.1 → 2.1.2

data/lib/valkyrie/indexers/access_controls_indexer.rb

@@ -40,24 +40,24 @@ module Valkyrie::Indexers
 
     private
 
-      # rubocop:disable Metrics/MethodLength
-      def default_config
-        if defined?(Hydra) && Hydra.respond_to?(:config)
-          {
-            read_groups: Hydra.config[:permissions][:read].group,
-            read_users: Hydra.config[:permissions][:read].individual,
-            edit_groups: Hydra.config[:permissions][:edit].group,
-            edit_users: Hydra.config[:permissions][:edit].individual
-          }
-        else
-          {
-            read_groups: 'read_access_group_ssim',
-            read_users: 'read_access_person_ssim',
-            edit_groups: 'edit_access_group_ssim',
-            edit_users: 'edit_access_person_ssim'
-          }
-        end
+    # rubocop:disable Metrics/MethodLength
+    def default_config
+      if defined?(Hydra) && Hydra.respond_to?(:config)
+        {
+          read_groups: Hydra.config[:permissions][:read].group,
+          read_users: Hydra.config[:permissions][:read].individual,
+          edit_groups: Hydra.config[:permissions][:edit].group,
+          edit_users: Hydra.config[:permissions][:edit].individual
+        }
+      else
+        {
+          read_groups: 'read_access_group_ssim',
+          read_users: 'read_access_person_ssim',
+          edit_groups: 'edit_access_group_ssim',
+          edit_users: 'edit_access_person_ssim'
+        }
       end
+    end
     # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/valkyrie/persistence/fedora/list_node.rb

@@ -85,60 +85,60 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      attr_reader :next_uri, :prev_uri, :node_cache
+    attr_reader :next_uri, :prev_uri, :node_cache
 
-      # Class used to populate the RDF graph structure for the linked lists
-      class Builder
-        attr_reader :uri, :graph
+    # Class used to populate the RDF graph structure for the linked lists
+    class Builder
+      attr_reader :uri, :graph
 
-        # @param uri [RDF::URI] the URI for the linked list in the graph store
-        # @param graph [RDF::Repository] the RDF graph to be populated
-        def initialize(uri, graph)
-          @uri = uri
-          @graph = graph
-        end
+      # @param uri [RDF::URI] the URI for the linked list in the graph store
+      # @param graph [RDF::Repository] the RDF graph to be populated
+      def initialize(uri, graph)
+        @uri = uri
+        @graph = graph
+      end
 
-        # Populates attributes for the LinkedNode
-        # @param instance [ListNode]
-        def populate(instance)
-          instance.proxy_for = resource.proxy_for
-          instance.proxy_in = resource.proxy_in
-          instance.next_uri = resource.next
-          instance.prev_uri = resource.prev
-        end
+      # Populates attributes for the LinkedNode
+      # @param instance [ListNode]
+      def populate(instance)
+        instance.proxy_for = resource.proxy_for
+        instance.proxy_in = resource.proxy_in
+        instance.next_uri = resource.next
+        instance.prev_uri = resource.prev
+      end
 
-        private
+      private
 
-          # Constructs a set of triples using ActiveTriples as objects
-          # @return [Valkyrie::Persistence::Fedora::ListNode::Resource]
-          def resource
-            @resource ||= Resource.new(uri, graph: graph)
-          end
+      # Constructs a set of triples using ActiveTriples as objects
+      # @return [Valkyrie::Persistence::Fedora::ListNode::Resource]
+      def resource
+        @resource ||= Resource.new(uri, graph: graph)
       end
+    end
 
-      # Class for providing a set of triples modeling linked list nodes
-      class Resource
-        def self.property(property, predicate:)
-          define_method property do
-            graph.query([uri, predicate, nil]).objects.first
-          end
+    # Class for providing a set of triples modeling linked list nodes
+    class Resource
+      def self.property(property, predicate:)
+        define_method property do
+          graph.query([uri, predicate, nil]).objects.first
+        end
 
-          define_method "#{property}=" do |val|
-            return if val.nil?
-            graph << [uri, predicate, val]
-          end
+        define_method "#{property}=" do |val|
+          return if val.nil?
+          graph << [uri, predicate, val]
         end
+      end
 
-        property :proxy_for, predicate: ::RDF::Vocab::ORE.proxyFor
-        property :proxy_in, predicate: ::RDF::Vocab::ORE.proxyIn
-        property :next, predicate: ::RDF::Vocab::IANA.next
-        property :prev, predicate: ::RDF::Vocab::IANA.prev
+      property :proxy_for, predicate: ::RDF::Vocab::ORE.proxyFor
+      property :proxy_in, predicate: ::RDF::Vocab::ORE.proxyIn
+      property :next, predicate: ::RDF::Vocab::IANA.next
+      property :prev, predicate: ::RDF::Vocab::IANA.prev
 
-        attr_reader :graph, :uri
-        def initialize(uri, graph: RDF::Graph.new)
-          @uri = uri
-          @graph = graph
-        end
+      attr_reader :graph, :uri
+      def initialize(uri, graph: RDF::Graph.new)
+        @uri = uri
+        @graph = graph
       end
+    end
   end
 end

data/lib/valkyrie/persistence/fedora/ordered_list.rb

@@ -67,111 +67,111 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      attr_reader :node_cache
-
-      # Append a node to a linked list
-      # @param source [ListNode] the node being appended
-      # @param append_node [ListNode] the node already in the existing list
-      def append_to(source, append_node)
-        source.prev = append_node
-        append_node.next.prev = source
-        source.next = append_node.next
-        append_node.next = source
-        @changed = true
-      end
+    attr_reader :node_cache
+
+    # Append a node to a linked list
+    # @param source [ListNode] the node being appended
+    # @param append_node [ListNode] the node already in the existing list
+    def append_to(source, append_node)
+      source.prev = append_node
+      append_node.next.prev = source
+      source.next = append_node.next
+      append_node.next = source
+      @changed = true
+    end
 
-      # Constructs a new OrderedReader for this OrderedList
-      # @return [OrderedReader]
-      def ordered_reader
-        OrderedReader.new(self)
-      end
+    # Constructs a new OrderedReader for this OrderedList
+    # @return [OrderedReader]
+    def ordered_reader
+      OrderedReader.new(self)
+    end
 
-      # Populates the list with constructed ListNode Objects
-      # @param subject [RDF::URI]
-      def build_node(subject = nil)
-        return nil unless subject
-        node_cache.fetch(subject) do
-          ListNode.new(node_cache, subject, adapter, graph)
-        end
+    # Populates the list with constructed ListNode Objects
+    # @param subject [RDF::URI]
+    def build_node(subject = nil)
+      return nil unless subject
+      node_cache.fetch(subject) do
+        ListNode.new(node_cache, subject, adapter, graph)
       end
+    end
 
-      # Generates hash URIs for the subject of the LinkedList
-      # Should one of these URIs already be in use, a new URI will be generated
-      # @return [RDF::URI]
-      def new_node_subject
-        node = ::RDF::URI("##{::RDF::Node.new.id}")
-        node = ::RDF::URI("##{::RDF::Node.new.id}") while node_cache.key?(node)
-        node
-      end
+    # Generates hash URIs for the subject of the LinkedList
+    # Should one of these URIs already be in use, a new URI will be generated
+    # @return [RDF::URI]
+    def new_node_subject
+      node = ::RDF::URI("##{::RDF::Node.new.id}")
+      node = ::RDF::URI("##{::RDF::Node.new.id}") while node_cache.key?(node)
+      node
+    end
 
-      # Class used for caching LinkedNode objects mapped to URIs
-      class NodeCache
-        def initialize
-          @cache ||= {}
-        end
+    # Class used for caching LinkedNode objects mapped to URIs
+    class NodeCache
+      def initialize
+        @cache ||= {}
+      end
 
-        # Retrieve the ListNode for a given URI
-        # If a block is passed, set its output to the cache
-        # @param uri [RDF::URI]
-        # @return [ListNode]
-        def fetch(uri)
-          @cache[uri] ||= yield if block_given?
-        end
+      # Retrieve the ListNode for a given URI
+      # If a block is passed, set its output to the cache
+      # @param uri [RDF::URI]
+      # @return [ListNode]
+      def fetch(uri)
+        @cache[uri] ||= yield if block_given?
+      end
 
-        # Determines whether or not the cache contains a key
-        # @param key [Object]
-        # @return [Boolean]
-        def key?(key)
-          @cache.key?(key)
-        end
+      # Determines whether or not the cache contains a key
+      # @param key [Object]
+      # @return [Boolean]
+      def key?(key)
+        @cache.key?(key)
       end
+    end
 
-      # Class modeling sentinels within the linked list
-      # @see https://en.wikipedia.org/wiki/Sentinel_value
-      class Sentinel
-        attr_reader :parent, :next, :prev
-        attr_writer :next, :prev
-
-        # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
-        # @param next_node [ListNode]
-        # @param prev_node [ListNode]
-        def initialize(parent, next_node: nil, prev_node: nil)
-          @parent = parent
-          @next = next_node
-          @prev = prev_node
-        end
+    # Class modeling sentinels within the linked list
+    # @see https://en.wikipedia.org/wiki/Sentinel_value
+    class Sentinel
+      attr_reader :parent, :next, :prev
+      attr_writer :next, :prev
+
+      # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
+      # @param next_node [ListNode]
+      # @param prev_node [ListNode]
+      def initialize(parent, next_node: nil, prev_node: nil)
+        @parent = parent
+        @next = next_node
+        @prev = prev_node
+      end
 
-        # Ensure that this always behaves like a NilClass
-        # @return [TrueClass]
-        def nil?
-          true
-        end
+      # Ensure that this always behaves like a NilClass
+      # @return [TrueClass]
+      def nil?
+        true
+      end
 
-        # Ensure that this does not have a URI
-        # @return [NilClass]
-        def rdf_subject
-          nil
-        end
+      # Ensure that this does not have a URI
+      # @return [NilClass]
+      def rdf_subject
+        nil
       end
+    end
 
-      class HeadSentinel < Sentinel
-        # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
-        # @param next_node [ListNode]
-        # @param prev_node [ListNode]
-        def initialize(*args)
-          super
-          @next ||= TailSentinel.new(parent, prev_node: self)
-        end
+    class HeadSentinel < Sentinel
+      # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
+      # @param next_node [ListNode]
+      # @param prev_node [ListNode]
+      def initialize(*args)
+        super
+        @next ||= TailSentinel.new(parent, prev_node: self)
       end
+    end
 
-      class TailSentinel < Sentinel
-        # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
-        # @param next_node [ListNode]
-        # @param prev_node [ListNode]
-        def initialize(*args)
-          super
-          prev.next = self if prev&.next != self
-        end
+    class TailSentinel < Sentinel
+      # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
+      # @param next_node [ListNode]
+      # @param prev_node [ListNode]
+      def initialize(*args)
+        super
+        prev.next = self if prev&.next != self
       end
+    end
   end
 end

data/lib/valkyrie/persistence/fedora/ordered_reader.rb

@@ -26,10 +26,10 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      # Access the "first" (head) node for the linked list
-      # @return [Valkyrie::Persistence::Fedora::OrderedList::HeadSentinel]
-      def first_head
-        root.head
-      end
+    # Access the "first" (head) node for the linked list
+    # @return [Valkyrie::Persistence::Fedora::OrderedList::HeadSentinel]
+    def first_head
+      root.head
+    end
   end
 end

data/lib/valkyrie/persistence/fedora/permissive_schema.rb

@@ -92,7 +92,7 @@ module Valkyrie::Persistence::Fedora
       existing_predicates = schema.find { |_k, v| v == RDF::URI(predicate.to_s) }
       predicate_name = predicate.to_s.gsub(URI_PREFIX, '')
 
-      return predicate_name if existing_predicates.nil? || existing_predicates.empty?
+      return predicate_name if existing_predicates.blank?
       existing_predicates.first
     end
   end

data/lib/valkyrie/persistence/fedora/persister.rb

@@ -86,97 +86,95 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      # Ensure that all alternate IDs for a given resource are persisted
-      # @param [Valkyrie::Resource] resource
-      # @return [Array<Valkyrie::Persistence::Fedora::AlternateIdentifier>]
-      def find_or_create_alternate_ids(resource)
-        return nil unless resource.try(:alternate_ids)
-
-        resource.alternate_ids.map do |alternate_identifier|
-          begin
-            adapter.query_service.find_by(id: alternate_identifier)
-          rescue ::Valkyrie::Persistence::ObjectNotFoundError
-            alternate_resource = ::Valkyrie::Persistence::Fedora::AlternateIdentifier.new(id: alternate_identifier)
-            adapter.persister.save(resource: alternate_resource)
-          end
-        end
+    # Ensure that all alternate IDs for a given resource are persisted
+    # @param [Valkyrie::Resource] resource
+    # @return [Array<Valkyrie::Persistence::Fedora::AlternateIdentifier>]
+    def find_or_create_alternate_ids(resource)
+      return nil unless resource.try(:alternate_ids)
+
+      resource.alternate_ids.map do |alternate_identifier|
+        adapter.query_service.find_by(id: alternate_identifier)
+      rescue ::Valkyrie::Persistence::ObjectNotFoundError
+        alternate_resource = ::Valkyrie::Persistence::Fedora::AlternateIdentifier.new(id: alternate_identifier)
+        adapter.persister.save(resource: alternate_resource)
       end
+    end
 
-      # Ensure that any Resources referenced by alternate IDs are deleted when a Resource has these IDs deleted
-      # @param [Valkyrie::Resource] updated_resource
-      def cleanup_alternate_resources(updated_resource)
-        persisted_resource = adapter.query_service.find_by(id: updated_resource.id)
-        removed_identifiers = persisted_resource.alternate_ids - updated_resource.alternate_ids
+    # Ensure that any Resources referenced by alternate IDs are deleted when a Resource has these IDs deleted
+    # @param [Valkyrie::Resource] updated_resource
+    def cleanup_alternate_resources(updated_resource)
+      persisted_resource = adapter.query_service.find_by(id: updated_resource.id)
+      removed_identifiers = persisted_resource.alternate_ids - updated_resource.alternate_ids
 
-        removed_identifiers.each do |removed_id|
-          adapter.persister.delete(resource: adapter.query_service.find_by(id: removed_id))
-        end
+      removed_identifiers.each do |removed_id|
+        adapter.persister.delete(resource: adapter.query_service.find_by(id: removed_id))
       end
+    end
 
-      # Ensure that any Resources referenced by alternate IDs are persisted when a Resource has these IDs added
-      # @param [Valkyrie::Resource] resource
-      # @param [Array<Valkyrie::Persistence::Fedora::AlternateIdentifier>] alternate_resources
-      # @return [Valkyrie::Resource]
-      def save_reference_to_resource(resource, alternate_resources)
-        alternate_resources.each do |alternate_resource|
-          alternate_resource.references = resource.id
-          adapter.persister.save(resource: alternate_resource)
-        end
-
-        resource
+    # Ensure that any Resources referenced by alternate IDs are persisted when a Resource has these IDs added
+    # @param [Valkyrie::Resource] resource
+    # @param [Array<Valkyrie::Persistence::Fedora::AlternateIdentifier>] alternate_resources
+    # @return [Valkyrie::Resource]
+    def save_reference_to_resource(resource, alternate_resources)
+      alternate_resources.each do |alternate_resource|
+        alternate_resource.references = resource.id
+        adapter.persister.save(resource: alternate_resource)
       end
 
-      # Generate the lock token for a Resource, and set it for attribute
-      # @param [Valkyrie::Resource] resource
-      # @return [Valkyrie::Persistence::OptimisticLockToken]
-      # @see https://github.com/samvera-labs/valkyrie/wiki/Optimistic-Locking
-      # @note Fedora's last modified response is not granular enough to produce an effective lock token
-      #   therefore, we use the same implementation as the memory adapter. This could fail to lock a
-      #   resource if Fedora updated this resource between the time it was saved and Valkyrie created
-      #   the token.
-      def generate_lock_token(resource)
-        return unless resource.optimistic_locking_enabled?
-        token = Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: adapter.id, token: Time.now.to_r)
-        resource.send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", token)
-      end
+      resource
+    end
 
-      # Determine whether or not a lock token is still valid for a persisted Resource
-      #   If the persisted Resource has been updated since it was last read into memory,
-      #   then the resouce in memory has been invalidated and Valkyrie::Persistence::StaleObjectError
-      #   is raised.
-      # @param [Valkyrie::Resource] resource
-      # @see https://github.com/samvera-labs/valkyrie/wiki/Optimistic-Locking
-      # @raise [Valkyrie::Persistence::StaleObjectError]
-      def validate_lock_token(resource)
-        return unless resource.optimistic_locking_enabled?
-        return if resource.id.blank?
-
-        current_lock_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find { |lock_token| lock_token.adapter_id == adapter.id }
-        return if current_lock_token.blank?
-
-        retrieved_lock_tokens = adapter.query_service.find_by(id: resource.id)[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
-        retrieved_lock_token = retrieved_lock_tokens.find { |lock_token| lock_token.adapter_id == adapter.id }
-        return if retrieved_lock_token.blank?
-
-        raise Valkyrie::Persistence::StaleObjectError, "The object #{resource.id} has been updated by another process." unless current_lock_token == retrieved_lock_token
-      end
+    # Generate the lock token for a Resource, and set it for attribute
+    # @param [Valkyrie::Resource] resource
+    # @return [Valkyrie::Persistence::OptimisticLockToken]
+    # @see https://github.com/samvera-labs/valkyrie/wiki/Optimistic-Locking
+    # @note Fedora's last modified response is not granular enough to produce an effective lock token
+    #   therefore, we use the same implementation as the memory adapter. This could fail to lock a
+    #   resource if Fedora updated this resource between the time it was saved and Valkyrie created
+    #   the token.
+    def generate_lock_token(resource)
+      return unless resource.optimistic_locking_enabled?
+      token = Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: adapter.id, token: Time.now.to_r)
+      resource.send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", token)
+    end
 
-      # Retrieve the lock token that holds Fedora's system-managed last-modified date
-      # @param [Valkyrie::Resource] resource
-      # @return [Valkyrie::Persistence::OptimisticLockToken]
-      def native_lock_token(resource)
-        return unless resource.optimistic_locking_enabled?
-        resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find { |lock_token| lock_token.adapter_id.to_s == "native-#{adapter.id}" }
-      end
+    # Determine whether or not a lock token is still valid for a persisted Resource
+    #   If the persisted Resource has been updated since it was last read into memory,
+    #   then the resouce in memory has been invalidated and Valkyrie::Persistence::StaleObjectError
+    #   is raised.
+    # @param [Valkyrie::Resource] resource
+    # @see https://github.com/samvera-labs/valkyrie/wiki/Optimistic-Locking
+    # @raise [Valkyrie::Persistence::StaleObjectError]
+    def validate_lock_token(resource)
+      return unless resource.optimistic_locking_enabled?
+      return if resource.id.blank?
+
+      current_lock_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find { |lock_token| lock_token.adapter_id == adapter.id }
+      return if current_lock_token.blank?
+
+      retrieved_lock_tokens = adapter.query_service.find_by(id: resource.id)[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
+      retrieved_lock_token = retrieved_lock_tokens.find { |lock_token| lock_token.adapter_id == adapter.id }
+      return if retrieved_lock_token.blank?
+
+      raise Valkyrie::Persistence::StaleObjectError, "The object #{resource.id} has been updated by another process." unless current_lock_token == retrieved_lock_token
+    end
 
-      # Set Fedora request headers:
-      # * `Prefer: handling=lenient; received="minimal"` allows us to avoid sending all server-managed triples
-      # * `If-Unmodified-Since` triggers Fedora's server-side optimistic locking
-      # @param request [Faraday::Request]
-      # @param lock_token [Valkyrie::Persistence::OptimisticLockToken]
-      def update_request_headers(request, lock_token)
-        request.headers["Prefer"] = "handling=lenient; received=\"minimal\""
-        request.headers["If-Unmodified-Since"] = lock_token.token if lock_token
-      end
+    # Retrieve the lock token that holds Fedora's system-managed last-modified date
+    # @param [Valkyrie::Resource] resource
+    # @return [Valkyrie::Persistence::OptimisticLockToken]
+    def native_lock_token(resource)
+      return unless resource.optimistic_locking_enabled?
+      resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find { |lock_token| lock_token.adapter_id.to_s == "native-#{adapter.id}" }
+    end
+
+    # Set Fedora request headers:
+    # * `Prefer: handling=lenient; received="minimal"` allows us to avoid sending all server-managed triples
+    # * `If-Unmodified-Since` triggers Fedora's server-side optimistic locking
+    # @param request [Faraday::Request]
+    # @param lock_token [Valkyrie::Persistence::OptimisticLockToken]
+    def update_request_headers(request, lock_token)
+      request.headers["Prefer"] = "handling=lenient; received=\"minimal\""
+      request.headers["If-Unmodified-Since"] = lock_token.token if lock_token
+    end
   end
 end