active-fedora 9.10.4 → 9.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45d18ff02bbb3fd1572b965ee3ab6a3264e12a39
-  data.tar.gz: b0dd1b79c85e2a29c374139b78ca20714a9dd649
+  metadata.gz: bce277ca040d2e5d2b6f20ad12ded43a0d09a81e
+  data.tar.gz: 41626c552b9571d1993bc95f3719a0b12a24eb5b
 SHA512:
-  metadata.gz: bc801e3d47c9284db763430bfd1adc32909189ce9d5d5a92eddf327820ad840e21a51ed072c41e911ff12675ca7aee227d2ec460cbff570a4e1d240eff4514fd
-  data.tar.gz: 3abc7c3ca73df8560b491d2d2b07eb17e1675f2ff38745adacc748ad45604e1b8e859307927e0bae8e88d5edd6a092056b992d8de84d0407e49fd71c3f466262
+  metadata.gz: b48ed0579be52f0683f6293adc4ff4908706d125f924119cabc2e01076bfcf2501e7732ef9b057948f6aeffd0f10679626d033aab52313523839020005d543ac
+  data.tar.gz: 2dfa7a8abb57bc8dc376da0767fd5d70ecf13bc9bbcb6f0542faaad5b8d70973367c1f81776aa8e4e704655029676b9ec124836f3736d1940c36a7e470b3092d

data/.rubocop.yml

@@ -87,6 +87,7 @@ Metrics/ClassLength:
     - 'lib/active_fedora/associations/collection_proxy.rb'
     - 'lib/active_fedora/associations/collection_association.rb'
     - 'lib/active_fedora/reflection.rb'
+    - 'lib/active_fedora/orders/ordered_list.rb'
 
 Metrics/MethodLength:
   Enabled: false
@@ -123,6 +124,8 @@ Style/PredicateName:
     - 'lib/active_fedora/attached_files.rb'
     - 'lib/active_fedora/associations.rb'
     - 'lib/active_fedora/association_hash.rb'
+    - 'lib/active_fedora/aggregation/list_source.rb'
+    - 'lib/active_fedora/associations/builder/aggregation.rb'
 
 Style/GuardClause:
   Exclude:

data/History.txt

@@ -1,16 +1,3 @@
-v9.10.4
-2016-03-28: Use a version of activesupport >= 4.2.4 [Justin Coyne]
-
-v9.10.3
-2016-03-28: Revert "ActiveFedora::File.mime_type should be updatable" [Justin
-Coyne]
-
-2016-03-28: Pin to rubocop 0.38 [Justin Coyne]
-
-v9.10.2
-2016-03-26: Pass the block from find_in_batches to search_in_batches [Justin
-Coyne]
-
 v9.10.1
 2016-03-26: Fix #reflect_on_association. [Trey Pendragon]
 

data/lib/active_fedora.rb

@@ -36,6 +36,7 @@ module ActiveFedora #:nodoc:
   extend ActiveSupport::Autoload
 
   eager_autoload do
+    autoload :Aggregation
     autoload :AssociationHash
     autoload :AssociationRelation
     autoload :Associations
@@ -76,6 +77,7 @@ module ActiveFedora #:nodoc:
     autoload :FilePersistence
     autoload :FileRelation
     autoload :FilesHash
+    autoload :Filter
     autoload :FixityService
     autoload :Identifiable
     autoload :Indexers
@@ -94,6 +96,7 @@ module ActiveFedora #:nodoc:
     autoload :NomDatastream
     autoload :NullRelation
     autoload :OmDatastream
+    autoload :Orders
     autoload :Pathing
     autoload :Persistence
     autoload :ProfileIndexingService
@@ -227,6 +230,10 @@ module ActiveFedora #:nodoc:
       ActiveFedora::SolrService.instance
     end
 
+    def reset_fedora!
+      @fedora = nil
+    end
+
     def fedora
       @fedora ||= Fedora.new(fedora_config.credentials)
     end

data/lib/active_fedora/aggregation.rb

@@ -0,0 +1,11 @@
+module ActiveFedora
+  module Aggregation
+    extend ActiveSupport::Autoload
+    eager_autoload do
+      autoload :Proxy
+      autoload :BaseExtension
+      autoload :OrderedReader
+      autoload :ListSource
+    end
+  end
+end

data/lib/active_fedora/aggregation/base_extension.rb

@@ -0,0 +1,17 @@
+module ActiveFedora::Aggregation
+  module BaseExtension
+    def ordered_by
+      ordered_by_ids.lazy.map { |x| ActiveFedora::Base.find(x) }
+    end
+
+    private
+
+      def ordered_by_ids
+        if id.present?
+          ActiveFedora::SolrService.query("{!join from=proxy_in_ssi to=id}ordered_targets_ssim:#{id}").map { |x| x["id"] }
+        else
+          []
+        end
+      end
+  end
+end

data/lib/active_fedora/aggregation/list_source.rb

@@ -0,0 +1,103 @@
+module ActiveFedora
+  module Aggregation
+    class ListSource < ActiveFedora::Base
+      delegate :order_will_change!, to: :ordered_self
+      property :head, predicate: ::RDF::Vocab::IANA['first'], multiple: false
+      property :tail, predicate: ::RDF::Vocab::IANA.last, multiple: false
+      property :nodes, predicate: ::RDF::Vocab::DC.hasPart
+
+      def save(*args)
+        return true if has_unpersisted_proxy_for? || !changed?
+        persist_ordered_self if ordered_self.changed?
+        super
+      end
+
+      # Overriding so that we don't track previously_changed, which was
+      # rather expensive.
+      def clear_changed_attributes
+        @changed_attributes.clear
+      end
+
+      def changed?
+        super || ordered_self.changed?
+      end
+
+      # Ordered list representation of proxies in graph.
+      # @return [Array<ListNode>]
+      def ordered_self
+        @ordered_self ||= ordered_list_factory.new(resource, head_subject, tail_subject)
+      end
+
+      # Allow this to be set so that -=, += will work.
+      # @param [ActiveFedora::Orders::OrderedList] An ordered list object this
+      #   graph should contain.
+      attr_writer :ordered_self
+
+      # Serializing head/tail/nodes slows things down CONSIDERABLY, and is not
+      # useful.
+      # @note This method is used by ActiveFedora::Base upstream for indexing,
+      #   at https://github.com/projecthydra/active_fedora/blob/master/lib/active_fedora/profile_indexing_service.rb.
+      def serializable_hash(_options = nil)
+        {}
+      end
+
+      def to_solr(solr_doc = {})
+        super.merge(ordered_targets_ssim: ordered_self.target_ids,
+                    proxy_in_ssi: ordered_self.proxy_in.to_s)
+      end
+
+      # Not useful and slows down indexing.
+      def create_date
+        nil
+      end
+
+      # Not useful, slows down indexing.
+      def modified_date
+        nil
+      end
+
+      # Not useful, slows down indexing.
+      def has_model
+        ["ActiveFedora::Aggregation::ListSource"]
+      end
+
+      private
+
+        def persist_ordered_self
+          nodes_will_change!
+          # Delete old statements
+          subj = resource.subjects.to_a.select { |x| x.to_s.split("/").last.to_s.include?("#g") }
+          subj.each do |s|
+            resource.delete [s, nil, nil]
+          end
+          # Assert head and tail
+          self.head = ordered_self.head.next.rdf_subject
+          self.tail = ordered_self.tail.prev.rdf_subject
+          graph = ordered_self.to_graph
+          resource << graph
+          # Set node subjects to a term in AF JUST so that AF will persist the
+          # sub-graphs.
+          # TODO: Find a way to fix this.
+          self.nodes = nil
+          self.nodes += graph.subjects.to_a
+          ordered_self.changes_committed!
+        end
+
+        def has_unpersisted_proxy_for?
+          ordered_self.select(&:new_record?).map(&:target).find { |x| x.respond_to?(:uri) }
+        end
+
+        def head_subject
+          head_id.first
+        end
+
+        def tail_subject
+          tail_id.first
+        end
+
+        def ordered_list_factory
+          ActiveFedora::Orders::OrderedList
+        end
+    end
+  end
+end

data/lib/active_fedora/aggregation/ordered_reader.rb

@@ -0,0 +1,27 @@
+module ActiveFedora::Aggregation
+  ##
+  # Lazily iterates over a doubly linked list, fixing up nodes if necessary.
+  class OrderedReader
+    include Enumerable
+    attr_reader :root
+    def initialize(root)
+      @root = root
+    end
+
+    def each
+      proxy = first_head
+      while proxy
+        yield proxy unless proxy.nil?
+        next_proxy = proxy.next
+        next_proxy.try(:prev=, proxy) if next_proxy && next_proxy.prev != proxy
+        proxy = next_proxy
+      end
+    end
+
+    private
+
+      def first_head
+        root.head
+      end
+  end
+end

data/lib/active_fedora/aggregation/proxy.rb

@@ -0,0 +1,18 @@
+module ActiveFedora::Aggregation
+  class Proxy < ActiveFedora::Base
+    belongs_to :container, predicate: ::RDF::Vocab::ORE.proxyIn, class_name: 'ActiveFedora::Base'
+    belongs_to :target, predicate: ::RDF::Vocab::ORE.proxyFor, class_name: 'ActiveFedora::Base'
+    belongs_to :next, predicate: ::RDF::Vocab::IANA.next, class_name: 'ActiveFedora::Aggregation::Proxy'
+    belongs_to :prev, predicate: ::RDF::Vocab::IANA.prev, class_name: 'ActiveFedora::Aggregation::Proxy'
+
+    type ::RDF::Vocab::ORE.Proxy
+
+    def as_list
+      if self.next
+        [self] + self.next.as_list
+      else
+        [self]
+      end
+    end
+  end
+end

data/lib/active_fedora/associations.rb

@@ -29,6 +29,8 @@ module ActiveFedora
     autoload :DirectlyContainsOneAssociation
     autoload :IndirectlyContainsAssociation
     autoload :ContainsAssociation
+    autoload :FilterAssociation
+    autoload :OrdersAssociation
     autoload :DeleteProxy
     autoload :ContainedFinder
     autoload :RecordComposite
@@ -50,6 +52,10 @@ module ActiveFedora
 
       autoload :Property,         'active_fedora/associations/builder/property'
       autoload :SingularProperty, 'active_fedora/associations/builder/singular_property'
+
+      autoload :Aggregation, 'active_fedora/associations/builder/aggregation'
+      autoload :Filter, 'active_fedora/associations/builder/filter'
+      autoload :Orders, 'active_fedora/associations/builder/orders'
     end
 
     eager_autoload do
@@ -280,6 +286,40 @@ module ActiveFedora
           Builder::HasAndBelongsToMany.build(self, name, options)
           Builder::Property.build(self, name, options.slice(:class_name, :predicate))
         end
+
+        ##
+        # Allows ordering of an association
+        # @example
+        #   class Image < ActiveFedora::Base
+        #     contains :list_resource, class_name:
+        #       "ActiveFedora::Aggregation::ListSource"
+        #     orders :generic_files, through: :list_resource
+        #   end
+        def orders(name, options = {})
+          Builder::Orders.build(self, name, options)
+        end
+
+        ##
+        # Convenience method for building an ordered aggregation.
+        # @example
+        #   class Image < ActiveFedora::Base
+        #     ordered_aggregation :members, through: :list_source
+        #   end
+        def ordered_aggregation(name, options = {})
+          Builder::Aggregation.build(self, name, options)
+        end
+
+        ##
+        # Create an association filter on the class
+        # @example
+        #   class Image < ActiveFedora::Base
+        #     aggregates :generic_files
+        #     filters_association :generic_files, as: :large_files, condition: :big_file?
+        #   end
+        def filters_association(extending_from, options = {})
+          name = options.delete(:as)
+          Builder::Filter.build(self, name, options.merge(extending_from: extending_from))
+        end
       end
   end
 end

data/lib/active_fedora/associations/builder/aggregation.rb

@@ -0,0 +1,51 @@
+module ActiveFedora::Associations::Builder
+  class Aggregation < ActiveFedora::Associations::Builder::Association
+    def self.valid_options(_options)
+      [:through, :class_name, :has_member_relation, :type_validator]
+    end
+
+    def self.build(model, name, options)
+      model.indirectly_contains name, { has_member_relation: has_member_relation(options), through: proxy_class, foreign_key: proxy_foreign_key, inserted_content_relation: inserted_content_relation }.merge(indirect_options(options))
+      model.contains contains_key(options), class_name: list_source_class
+      model.orders name, through: contains_key(options)
+    end
+
+    def self.indirect_options(options)
+      {
+        class_name: options[:class_name],
+        type_validator: options[:type_validator]
+      }.select { |_k, v| v.present? }
+    end
+    private_class_method :indirect_options
+
+    def self.has_member_relation(options)
+      options[:has_member_relation] || ::RDF::DC.hasPart
+    end
+    private_class_method :has_member_relation
+
+    def self.inserted_content_relation
+      ::RDF::Vocab::ORE.proxyFor
+    end
+    private_class_method :inserted_content_relation
+
+    def self.proxy_class
+      "ActiveFedora::Aggregation::Proxy"
+    end
+    private_class_method :proxy_class
+
+    def self.proxy_foreign_key
+      :target
+    end
+    private_class_method :proxy_foreign_key
+
+    def self.contains_key(options)
+      options[:through]
+    end
+    private_class_method :contains_key
+
+    def self.list_source_class
+      "ActiveFedora::Aggregation::ListSource"
+    end
+    private_class_method :list_source_class
+  end
+end

data/lib/active_fedora/associations/builder/filter.rb

@@ -0,0 +1,18 @@
+module ActiveFedora::Associations::Builder
+  class Filter < ActiveFedora::Associations::Builder::CollectionAssociation
+    def self.valid_options(options)
+      super + [:extending_from, :condition]
+    end
+
+    def self.macro
+      :filter
+    end
+
+    def self.define_readers(mixin, name)
+      super
+      mixin.redefine_method("#{name.to_s.singularize}_ids") do
+        association(name).ids_reader
+      end
+    end
+  end
+end

data/lib/active_fedora/associations/builder/orders.rb

@@ -0,0 +1,63 @@
+module ActiveFedora::Associations::Builder
+  class Orders < ActiveFedora::Associations::Builder::CollectionAssociation
+    include ActiveFedora::AutosaveAssociation::AssociationBuilderExtension
+    def self.macro
+      :orders
+    end
+
+    def self.valid_options(options)
+      super + [:through, :unordered_reflection]
+    end
+
+    def self.define_readers(mixin, name)
+      super
+      mixin.redefine_method(target_accessor(name)) do
+        association(name).target_reader
+      end
+      mixin.redefine_method("#{target_accessor(name)}=") do |nodes|
+        association(name).target_writer(nodes)
+      end
+    end
+
+    def self.build(model, name, options)
+      options = { unordered_reflection: unordered_reflection(model, name) }.merge(options)
+      name = :"ordered_#{name.to_s.singularize}_proxies"
+      model.property :head, predicate: ::RDF::Vocab::IANA['first']
+      model.property :tail, predicate: ::RDF::Vocab::IANA.last
+      model.send(:define_method, :apply_first_and_last) do
+        source = send(options[:through])
+        source.save
+        return if head.map(&:rdf_subject) == source.head_id && tail.map(&:rdf_subject) == source.tail_id
+        self.head = source.head_id
+        self.tail = source.tail_id
+        save! if changed?
+      end
+      model.include ActiveFedora::Associations::Builder::Orders::FixFirstLast
+      super
+    end
+
+    module FixFirstLast
+      def save(*args)
+        super.tap do |result|
+          apply_first_and_last if result
+        end
+      end
+
+      def save!(*args)
+        super.tap do |result|
+          apply_first_and_last if result
+        end
+      end
+    end
+
+    def self.target_accessor(name)
+      name.to_s.gsub("_proxies", "").pluralize
+    end
+    private_class_method :target_accessor
+
+    def self.unordered_reflection(model, original_name)
+      model._reflect_on_association(original_name)
+    end
+    private_class_method :unordered_reflection
+  end
+end