active-fedora 9.10.4 → 9.11.0

data/lib/active_fedora/associations/filter_association.rb

@@ -0,0 +1,71 @@
+module ActiveFedora::Associations
+  class FilterAssociation < ::ActiveFedora::Associations::CollectionAssociation
+    # @param [Array] records a list of records to replace the current association with
+    # @raise [ArgumentError] if one of the records doesn't match the prescribed condition
+    def writer(records)
+      records.each { |r| validate_assertion!(r) }
+      existing_matching_records.each do |r|
+        extending_from.delete(r)
+      end
+      extending_from.concat(records)
+    end
+
+    delegate :delete, to: :extending_from
+
+    # @param [Array] records a list of records to append to the current association
+    # @raise [ArgumentError] if one of the records doesn't match the prescribed condition
+    def concat(records)
+      records.flatten.each { |r| validate_assertion!(r) }
+      extending_from.concat(records)
+    end
+
+    def ids_reader
+      load_target
+      super
+    end
+
+    def count_records
+      ids_reader.length
+    end
+
+    private
+
+      # target should never be cached as part of this objects state, because
+      # extending_from.target could change and we want to reflect those changes
+      def target
+        find_target
+      end
+
+      def find_target?
+        true
+      end
+
+      def find_target
+        existing_matching_records
+      end
+
+      # We can't create an association scope on here until we can figure a way to
+      # index/query the condition in Solr
+      def association_scope
+        nil
+      end
+
+      def existing_matching_records
+        extending_from.reader.to_a.select do |r|
+          validate_assertion(r)
+        end
+      end
+
+      def extending_from
+        owner.association(options.fetch(:extending_from))
+      end
+
+      def validate_assertion(record)
+        record.send(options.fetch(:condition))
+      end
+
+      def validate_assertion!(record)
+        raise ArgumentError, "#{record.class} with ID: #{record.id} was expected to #{options.fetch(:condition)}, but it was false" unless validate_assertion(record)
+      end
+  end
+end

data/lib/active_fedora/associations/orders_association.rb

@@ -0,0 +1,149 @@
+module ActiveFedora::Associations
+  class OrdersAssociation < ::ActiveFedora::Associations::CollectionAssociation
+    def initialize(*args)
+      super
+      @target = find_target
+    end
+
+    def inspect
+      "#<ActiveFedora::Associations::OrdersAssociation:#{object_id}>"
+    end
+
+    def reader(*args)
+      @proxy ||= ActiveFedora::Orders::CollectionProxy.new(self)
+      @null_proxy ||= ActiveFedora::Orders::CollectionProxy.new(self)
+      super
+    end
+
+    # Meant to override all nodes with the given nodes.
+    # @param [Array<ActiveFedora::Base>] nodes Nodes to set as ordered members
+    def target_writer(nodes)
+      target_reader.clear
+      target_reader.concat(nodes)
+      target_reader
+    end
+
+    def target_reader
+      @target_proxy ||= ActiveFedora::Orders::TargetProxy.new(self)
+    end
+
+    def find_reflection
+      reflection
+    end
+
+    def replace(new_ordered_list)
+      raise unless new_ordered_list.is_a? ActiveFedora::Orders::OrderedList
+      list_container.ordered_self = new_ordered_list
+      @target = find_target
+    end
+
+    def find_target
+      ordered_proxies
+    end
+
+    def load_target
+      @target = find_target
+    end
+
+    # Append a target node to the end of the order.
+    # @param [ActiveFedora::Base] record Record to append
+    def append_target(record, _skip_callbacks = false)
+      unless unordered_association.target.include?(record)
+        unordered_association.concat(record)
+      end
+      target.append_target(record, proxy_in: owner)
+    end
+
+    # Insert a target node in a specific position
+    # @param [Integer] loc Position to insert record.
+    # @param [ActiveFedora::Base] record Record to insert
+    def insert_target_at(loc, record)
+      unless unordered_association.target.include?(record)
+        unordered_association.concat(record)
+      end
+      target.insert_at(loc, record, proxy_in: owner)
+    end
+
+    # Insert a target ID in a specific position
+    # @param [Integer] loc Position to insert record ID
+    # @param [String] id ID of record to insert.
+    def insert_target_id_at(loc, id)
+      raise ArgumentError, "ID can not be nil" if id.nil?
+      unless unordered_association.ids_reader.include?(id)
+        raise ArgumentError, "#{id} is not a part of #{unordered_association.reflection.name}"
+      end
+      target.insert_proxy_for_at(loc, ActiveFedora::Base.id_to_uri(id), proxy_in: owner)
+    end
+
+    # Delete whatever node is at a specific position
+    # @param [Integer] loc Position to delete
+    delegate :delete_at, to: :target
+
+    # Delete all occurences of the specified target
+    # @param obj object to delete
+    delegate :delete_target, to: :target
+
+    # Delete multiple list nodes.
+    # @param [Array<ActiveFedora::Orders::ListNode>] records
+    def delete_records(records, _method = nil)
+      records.each do |record|
+        delete_record(record)
+      end
+    end
+
+    # Delete a list node
+    # @param [ActiveFedora::Orders::ListNode] record Node to delete.
+    def delete_record(record)
+      target.delete_node(record)
+    end
+
+    def insert_record(record, _force = true, _validate = true)
+      record.save_target
+      list_container.save
+      # NOTE: This turns out to be pretty cheap, but should we be doing it
+      # elsewhere?
+      unless list_container.changed?
+        owner.head = [list_container.head_id.first]
+        owner.tail = [list_container.tail_id.first]
+        owner.save
+      end
+    end
+
+    def scope(*_args)
+      @scope ||= ActiveFedora::Relation.new(klass)
+    end
+
+    private
+
+      def ordered_proxies
+        list_container.ordered_self
+      end
+
+      def create_list_node(record)
+        node = ListNode.new(RDF::URI.new("#{list_container.uri}##{::RDF::Node.new.id}"), list_container.resource)
+        node.proxyIn = owner
+        node.proxyFor = record
+        node
+      end
+
+      def association_scope
+        nil
+      end
+
+      def list_container
+        list_container_association.reader
+      end
+
+      def list_container_association
+        owner.association(options[:through])
+      end
+
+      def unordered_association
+        owner.association(unordered_reflection_name)
+      end
+
+      def unordered_reflection_name
+        reflection.unordered_reflection.name
+      end
+  end
+end

data/lib/active_fedora/attached_files.rb

@@ -131,7 +131,8 @@ module ActiveFedora
 
       def create_singleton_association(file_path)
         undeclared_files << file_path.to_sym
-        association = Associations::BasicContainsAssociation.new(self, Reflection::AssociationReflection.new(:contains, file_path, nil, { class_name: 'ActiveFedora::File' }, self.class))
+
+        association = Associations::BasicContainsAssociation.new(self, Reflection::ContainsReflection.new(file_path, nil, { class_name: 'ActiveFedora::File' }, self.class))
         @association_cache[file_path.to_sym] = association
 
         singleton_class.send :define_method, accessor_name(file_path) do

data/lib/active_fedora/attribute_methods.rb

@@ -31,23 +31,23 @@ module ActiveFedora
         super
       end
 
-      # Raises an ActiveRecord::DangerousAttributeError exception when an
+      # Raises an ActiveFedora::DangerousAttributeError exception when an
       # \Active \Record method is defined in the model, otherwise +false+.
       #
       #   class Person < ActiveRecord::Base
       #     def save
-      #       'already defined by Active Record'
+      #       'already defined by Active Fedora'
       #     end
       #   end
       #
       #   Person.instance_method_already_implemented?(:save)
-      #   # => ActiveRecord::DangerousAttributeError: save is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name.
+      #   # => ActiveFedora::DangerousAttributeError: save is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name.
       #
       #   Person.instance_method_already_implemented?(:name)
       #   # => false
       def instance_method_already_implemented?(method_name)
         if dangerous_attribute_method?(method_name)
-          raise DangerousAttributeError, "#{method_name} is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name."
+          raise DangerousAttributeError, "#{method_name} is defined by Active Fedora. Check to make sure that you don't have an attribute or method with the same name."
         end
 
         if superclass == Base

data/lib/active_fedora/autosave_association.rb

@@ -153,6 +153,7 @@ module ActiveFedora
     # Reloads the attributes of the object as usual and clears <tt>marked_for_destruction</tt> flag.
     def reload
       @marked_for_destruction = false
+      @destroyed_by_association = nil
       super
     end
 
@@ -172,6 +173,19 @@ module ActiveFedora
       @marked_for_destruction
     end
 
+    # Records the association that is being destroyed and destroying this
+    # record in the process.
+    def destroyed_by_association=(reflection)
+      @destroyed_by_association = reflection
+    end
+
+    # Returns the association for the parent being destroyed.
+    #
+    # Used to avoid updating the counter cache unnecessarily.
+    def destroyed_by_association
+      @destroyed_by_association
+    end
+
     # Returns whether or not this record has been changed in any way (including whether
     # any of its nested autosave associations are likewise changed)
     def changed_for_autosave?

data/lib/active_fedora/base.rb

@@ -51,6 +51,7 @@ module ActiveFedora
     include LoadableFromJson
     include Schema
     include Pathing
+    include Aggregation::BaseExtension
   end
 
   ActiveSupport.run_load_hooks(:active_fedora, Base)

data/lib/active_fedora/cleaner.rb

@@ -44,7 +44,7 @@ module ActiveFedora
     end
 
     def self.reinitialize_repo
-      ActiveFedora.fedora.init_base_path
+      ActiveFedora.reset_fedora!
     end
 
     def self.log(message)

data/lib/active_fedora/errors.rb

@@ -121,4 +121,7 @@ module ActiveFedora #:nodoc:
   # Raised when you try to set a URI to an already persisted Base object.
   class AlreadyPersistedError < ActiveFedoraError
   end
+
+  class DangerousAttributeError < ActiveFedoraError
+  end
 end

data/lib/active_fedora/fedora.rb

@@ -2,7 +2,6 @@ module ActiveFedora
   class Fedora
     def initialize(config)
       @config = config
-      init_base_path
     end
 
     def host
@@ -26,11 +25,10 @@ module ActiveFedora
     end
 
     def connection
-      # The InboundRelationConnection does provide more data, useful for
-      # things like ldp:IndirectContainers, but it's imposes a significant
-      # performance penalty on every request
-      #   @connection ||= InboundRelationConnection.new(CachingConnection.new(authorized_connection))
-      @connection ||= CachingConnection.new(authorized_connection, omit_ldpr_interaction_model: true)
+      @connection ||= begin
+        init_base_path
+        build_connection
+      end
     end
 
     def clean_connection
@@ -46,14 +44,18 @@ module ActiveFedora
 
     # Call this to create a Container Resource to act as the base path for this connection
     def init_base_path
+      return if @initialized
+      connection = build_connection
+
       connection.head(root_resource_path)
       ActiveFedora::Base.logger.info "Attempted to init base path `#{root_resource_path}`, but it already exists" if ActiveFedora::Base.logger
+      @initialized = true
       false
     rescue Ldp::NotFound
       unless host.downcase.end_with?("/rest")
         ActiveFedora::Base.logger.warn "Fedora URL (#{host}) does not end with /rest. This could be a problem. Check your fedora.yml config"
       end
-      connection.put(root_resource_path, BLANK).success?
+      @initialized = connection.put(root_resource_path, BLANK).success?
     end
 
     # Remove a leading slash from the base_path
@@ -61,6 +63,14 @@ module ActiveFedora
       @root_resource_path ||= base_path.sub(SLASH, BLANK)
     end
 
+    def build_connection
+      # The InboundRelationConnection does provide more data, useful for
+      # things like ldp:IndirectContainers, but it's imposes a significant
+      # performance penalty on every request
+      #   @connection ||= InboundRelationConnection.new(CachingConnection.new(authorized_connection))
+      CachingConnection.new(authorized_connection, omit_ldpr_interaction_model: true)
+    end
+
     def authorized_connection
       options = {}
       options[:ssl] = ssl_options if ssl_options

data/lib/active_fedora/file/streaming.rb

@@ -22,13 +22,22 @@ module ActiveFedora::File::Streaming
       @headers = headers
     end
 
-    def each
+    def each(no_of_requests_limit = 3, &block)
+      raise ArgumentError, 'HTTP redirect too deep' if no_of_requests_limit == 0
       Net::HTTP.start(uri.host, uri.port) do |http|
         request = Net::HTTP::Get.new uri, headers
         http.request request do |response|
-          raise "Couldn't get data from Fedora (#{uri}). Response: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
-          response.read_body do |chunk|
-            yield chunk
+          case response
+          when Net::HTTPSuccess
+            response.read_body do |chunk|
+              yield chunk
+            end
+          when Net::HTTPRedirection
+            no_of_requests_limit -= 1
+            @uri = URI(response["location"])
+            each(no_of_requests_limit, &block)
+          else
+            raise "Couldn't get data from Fedora (#{uri}). Response: #{response.code}"
           end
         end
       end

data/lib/active_fedora/orders.rb

@@ -0,0 +1,12 @@
+module ActiveFedora
+  module Orders
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :CollectionProxy
+      autoload :ListNode
+      autoload :OrderedList
+      autoload :TargetProxy
+    end
+  end
+end

data/lib/active_fedora/orders/collection_proxy.rb

@@ -0,0 +1,8 @@
+module ActiveFedora
+  module Orders
+    class CollectionProxy < ActiveFedora::Associations::CollectionProxy
+      attr_reader :association
+      delegate :append_target, :insert_target_at, :insert_target_id_at, :delete_at, to: :association
+    end
+  end
+end

data/lib/active_fedora/orders/list_node.rb

@@ -0,0 +1,161 @@
+module ActiveFedora::Orders
+  class ListNode
+    attr_reader :rdf_subject
+    attr_accessor :prev, :next, :target
+    attr_writer :next_uri, :prev_uri
+    attr_accessor :proxy_in, :proxy_for
+    def initialize(node_cache, rdf_subject, graph = RDF::Graph.new)
+      @rdf_subject = rdf_subject
+      @graph = graph
+      @node_cache = node_cache
+      Builder.new(rdf_subject, graph).populate(self)
+    end
+
+    # Returns the next proxy or a tail sentinel.
+    # @return [ActiveFedora::Orders::ListNode]
+    def next
+      @next ||=
+        if next_uri
+          node_cache.fetch(next_uri) do
+            node = self.class.new(node_cache, next_uri, graph)
+            node.prev = self
+            node
+          end
+        end
+    end
+
+    # Returns the previous proxy or a head sentinel.
+    # @return [ActiveFedora::Orders::ListNode]
+    def prev
+      @prev ||=
+        if prev_uri
+          node_cache.fetch(prev_uri) do
+            node = self.class.new(node_cache, prev_uri, graph)
+            node.next = self
+            node
+          end
+        end
+    end
+
+    # Graph representation of node.
+    # @return [ActiveFedora::Orders::ListNode::Resource]
+    def to_graph
+      g = Resource.new(rdf_subject)
+      g.proxy_for = target_uri
+      g.proxy_in = proxy_in.try(:uri)
+      g.next = self.next.try(:rdf_subject)
+      g.prev = prev.try(:rdf_subject)
+      g
+    end
+
+    # Object representation of proxyFor
+    # @return [ActiveFedora::Base]
+    def target
+      @target ||=
+        if proxy_for.present?
+          node_cache.fetch(proxy_for) do
+            ActiveFedora::Base.from_uri(proxy_for, nil)
+          end
+        end
+    end
+
+    def target_uri
+      RDF::URI(ActiveFedora::Base.id_to_uri(target_id)) if target_id
+    end
+
+    def target_id
+      MaybeID.new(@target.try(:id) || proxy_for).value
+    end
+
+    # Persists target if it's been accessed or set.
+    def save_target
+      if @target
+        @target.save
+      else
+        true
+      end
+    end
+
+    def proxy_in_id
+      MaybeID.new(@proxy_in.try(:id) || proxy_in).value
+    end
+
+    # Returns an ID whether or not the given value is a URI.
+    class MaybeID
+      attr_reader :uri_or_id
+      def initialize(uri_or_id)
+        @uri_or_id = uri_or_id
+      end
+
+      def value
+        id_composite.new([uri_or_id], translator).to_a.first
+      end
+
+      private
+
+        def id_composite
+          ActiveFedora::Associations::IDComposite
+        end
+
+        def translator
+          ActiveFedora::Base.translate_uri_to_id
+        end
+    end
+
+    # Methods necessary for association functionality
+    def destroyed?
+      false
+    end
+
+    def marked_for_destruction?
+      false
+    end
+
+    def valid?
+      true
+    end
+
+    def changed_for_autosave?
+      true
+    end
+
+    def new_record?
+      @target && @target.new_record?
+    end
+
+    private
+
+      attr_reader :next_uri, :prev_uri, :graph, :node_cache
+
+      class Builder
+        attr_reader :uri, :graph
+        def initialize(uri, graph)
+          @uri = uri
+          @graph = graph
+        end
+
+        def populate(instance)
+          instance.proxy_for = resource.proxy_for.first
+          instance.proxy_in = resource.proxy_in.first
+          instance.next_uri = resource.next.first
+          instance.prev_uri = resource.prev.first
+        end
+
+        private
+
+          def resource
+            @resource ||= Resource.new(uri, graph)
+          end
+      end
+
+      class Resource < ActiveTriples::Resource
+        property :proxy_for, predicate: ::RDF::Vocab::ORE.proxyFor, cast: false
+        property :proxy_in, predicate: ::RDF::Vocab::ORE.proxyIn, cast: false
+        property :next, predicate: ::RDF::Vocab::IANA.next, cast: false
+        property :prev, predicate: ::RDF::Vocab::IANA.prev, cast: false
+        def final_parent
+          parent
+        end
+      end
+  end
+end