active-fedora 9.10.4 → 9.11.0

data/lib/active_fedora/orders/ordered_list.rb

@@ -0,0 +1,264 @@
+module ActiveFedora
+  module Orders
+    ##
+    # Ruby object representation of an ORE doubly linked list.
+    class OrderedList
+      include Enumerable
+      attr_reader :graph, :head_subject, :tail_subject
+      attr_writer :head, :tail
+      delegate :each, to: :ordered_reader
+      delegate :length, to: :to_a
+      # @param [::RDF::Enumerable] graph Enumerable where ORE statements are
+      #   stored.
+      # @param [::RDF::URI] head_subject URI of head node in list.
+      # @param [::RDF::URI] tail_subject URI of tail node in list.
+      def initialize(graph, head_subject, tail_subject)
+        @graph = graph
+        @head_subject = head_subject
+        @tail_subject = tail_subject
+        @node_cache ||= NodeCache.new
+        @changed = false
+        tail
+      end
+
+      # @return [HeadSentinel] Sentinel for the top of the list. If not empty,
+      #  head.next is the first element.
+      def head
+        @head ||= HeadSentinel.new(self, next_node: build_node(head_subject))
+      end
+
+      # @return [TailSentinel] Sentinel for the bottom of the list. If not
+      #   empty, tail.prev is the first element.
+      def tail
+        @tail ||=
+          begin
+            if tail_subject
+              TailSentinel.new(self, prev_node: build_node(tail_subject))
+            else
+              head.next
+            end
+          end
+      end
+
+      # @param [Integer] key Position of the proxy
+      # @return [ListNode] Node for the proxy at the given position
+      def [](key)
+        list = ordered_reader.take(key + 1)
+        list[key]
+      end
+
+      # @return [ListNode] Last node in the list.
+      def last
+        if empty?
+          nil
+        else
+          tail.prev
+        end
+      end
+
+      # @param [Array<ListNode>] Nodes to remove.
+      # @return [OrderedList] List with node removed.
+      def -(other)
+        other.each do |node|
+          delete_node(node)
+        end
+        self
+      end
+
+      # @return [Boolean]
+      def empty?
+        head.next == tail
+      end
+
+      # @param [ActiveFedora::Base] target Target to append to list.
+      # @option [::RDF::URI, ActiveFedora::Base] :proxy_in Proxy in to
+      #   assert on the created node.
+      def append_target(target, proxy_in: nil)
+        node = build_node(new_node_subject)
+        node.target = target
+        node.proxy_in = proxy_in
+        append_to(node, tail.prev)
+      end
+
+      # @param [Integer] loc Location to insert target at
+      # @param [ActiveFedora::Base] target Target to insert
+      def insert_at(loc, target, proxy_in: nil)
+        node = build_node(new_node_subject)
+        node.target = target
+        node.proxy_in = proxy_in
+        if loc == 0
+          append_to(node, head)
+        else
+          append_to(node, ordered_reader.take(loc).last)
+        end
+      end
+
+      # @param [Integer] loc Location to insert target at
+      # @param [String] proxy_for proxyFor to add
+      def insert_proxy_for_at(loc, proxy_for, proxy_in: nil)
+        node = build_node(new_node_subject)
+        node.proxy_for = proxy_for
+        node.proxy_in = proxy_in
+        if loc == 0
+          append_to(node, head)
+        else
+          append_to(node, ordered_reader.take(loc).last)
+        end
+      end
+
+      # @param [ListNode] node Node to delete
+      def delete_node(node)
+        node = ordered_reader.find { |x| x == node }
+        if node
+          prev_node = node.prev
+          next_node = node.next
+          node.prev.next = next_node
+          node.next.prev = prev_node
+          @changed = true
+          node
+        end
+      end
+
+      # @param [Integer] loc Index of node to delete.
+      def delete_at(loc)
+        return nil if loc.nil?
+        arr = ordered_reader.take(loc + 1)
+        delete_node(arr.last) if arr.length == loc + 1
+      end
+
+      # @param obj target of node to delete.
+      def delete_target(obj)
+        nodes_to_remove = ordered_reader.select { |list_node| obj.id == list_node.target_id }
+        nodes_to_remove.each { |list_node| delete_node(list_node) }
+        nodes_to_remove.last.try(:target)
+      end
+
+      # @return [Boolean] Whether this list was changed since instantiation.
+      def changed?
+        @changed
+      end
+
+      # Marks this ordered list as about to change. Useful for when changing
+      # proxies individually.
+      def order_will_change!
+        @changed = true
+      end
+
+      # @return [::RDF::Graph] Graph representation of this list.
+      def to_graph
+        ::RDF::Graph.new.tap do |g|
+          array = to_a
+          array.map(&:to_graph).each do |resource_graph|
+            g << resource_graph
+          end
+        end
+      end
+
+      # Marks this list as not changed.
+      def changes_committed!
+        @changed = false
+      end
+
+      # @return IDs of all ordered targets, in order
+      def target_ids
+        to_a.map(&:target_id)
+      end
+
+      # @return The node all proxies are a proxy in.
+      # @note If there are multiple proxy_ins this will log a warning and return
+      #   the first.
+      def proxy_in
+        proxies = to_a.map(&:proxy_in_id).compact.uniq
+        if proxies.length > 1
+          ActiveFedora::Base.logger.warn "WARNING: List contains nodes aggregated under different URIs. Returning only the first." if ActiveFedora::Base.logger
+        end
+        proxies.first
+      end
+
+      private
+
+        attr_reader :node_cache
+
+        def append_to(source, append_node)
+          source.prev = append_node
+          if append_node.next
+            append_node.next.prev = source
+            source.next = append_node.next
+          else
+            self.tail = source
+          end
+          append_node.next = source
+          @changed = true
+        end
+
+        def ordered_reader
+          ActiveFedora::Aggregation::OrderedReader.new(self)
+        end
+
+        def build_node(subject = nil)
+          return nil unless subject
+          node_cache.fetch(subject) do
+            ActiveFedora::Orders::ListNode.new(node_cache, subject, graph)
+          end
+        end
+
+        def new_node_subject
+          node = ::RDF::URI("##{::RDF::Node.new.id}")
+          while node_cache.key?(node)
+            node = ::RDF::URI("##{::RDF::Node.new.id}")
+          end
+          node
+        end
+
+        class NodeCache
+          def initialize
+            @cache ||= {}
+          end
+
+          def fetch(uri)
+            @cache[uri] ||= yield if block_given?
+          end
+
+          def key?(key)
+            @cache.key?(key)
+          end
+        end
+
+        class Sentinel
+          attr_reader :parent
+          attr_writer :next, :prev
+          def initialize(parent, next_node: nil, prev_node: nil)
+            @parent = parent
+            @next = next_node
+            @prev = prev_node
+          end
+
+          attr_reader :next
+
+          attr_reader :prev
+
+          def nil?
+            true
+          end
+
+          def rdf_subject
+            nil
+          end
+        end
+
+        class HeadSentinel < Sentinel
+          def initialize(*args)
+            super
+            @next ||= TailSentinel.new(parent, prev_node: self)
+          end
+        end
+
+        class TailSentinel < Sentinel
+          def initialize(*args)
+            super
+            prev.next = self if prev && prev.next != self
+          end
+        end
+    end
+  end
+end

data/lib/active_fedora/orders/target_proxy.rb

@@ -0,0 +1,60 @@
+module ActiveFedora
+  module Orders
+    class TargetProxy
+      attr_reader :association
+      delegate :+, to: :to_a
+      def initialize(association)
+        @association = association
+      end
+
+      def <<(obj)
+        association.append_target(obj)
+        self
+      end
+
+      def concat(objs)
+        objs.each do |obj|
+          self.<<(obj)
+        end
+        self
+      end
+
+      def insert_at(loc, record)
+        association.insert_target_at(loc, record)
+        self
+      end
+
+      # Deletes the element at the specified index, returning that element, or nil if
+      # the index is out of range.
+      def delete_at(loc)
+        result = association.delete_at(loc)
+        result.target if result
+      end
+
+      # Deletes all items from self that are equal to obj.
+      # @param obj the object to remove from the list
+      # @return the last deleted item, or nil if no matching item is found
+      def delete(obj)
+        association.delete_target(obj)
+      end
+
+      def clear
+        association.delete_at(0) while to_ary.present?
+      end
+
+      def to_ary
+        association.reader.map(&:target).dup
+      end
+      alias to_a to_ary
+
+      def ==(other)
+        case other
+        when TargetProxy
+          super
+        when Array
+          to_a == other
+        end
+      end
+    end
+  end
+end

data/lib/active_fedora/reflection.rb

@@ -14,12 +14,32 @@ module ActiveFedora
     class << self
       def create(macro, name, scope, options, active_fedora)
         klass = case macro
-                when :has_many, :belongs_to, :has_and_belongs_to_many, :contains, :directly_contains, :directly_contains_one, :indirectly_contains
-                  AssociationReflection
-                when :rdf, :singular_rdf
+                when :has_many
+                  HasManyReflection
+                when :belongs_to
+                  BelongsToReflection
+                when :has_and_belongs_to_many
+                  HasAndBelongsToManyReflection
+                when :contains
+                  ContainsReflection
+                when :directly_contains
+                  DirectlyContainsReflection
+                when :directly_contains_one
+                  DirectlyContainsOneReflection
+                when :indirectly_contains
+                  IndirectlyContainsReflection
+                when :rdf
                   RDFPropertyReflection
+                when :singular_rdf
+                  SingularRDFPropertyReflection
+                when :filter
+                  FilterReflection
+                when :aggregation, :orders
+                  OrdersReflection
+                else
+                  raise "Unsupported Macro: #{macro}"
                 end
-        reflection = klass.new(macro, name, scope, options, active_fedora)
+        reflection = klass.new(name, scope, options, active_fedora)
         add_reflection(active_fedora, name, reflection)
         reflection
       end
@@ -185,11 +205,6 @@ module ActiveFedora
 
       attr_reader :scope
 
-      # Returns the macro type.
-      #
-      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
-      attr_reader :macro
-
       # Returns the hash of options used for the macro.
       #
       # <tt>has_many :clients</tt> returns +{}+
@@ -197,8 +212,7 @@ module ActiveFedora
 
       attr_reader :active_fedora
 
-      def initialize(macro, name, scope, options, active_fedora)
-        @macro = macro
+      def initialize(name, scope, options, active_fedora)
         @name = name
         @scope = scope
         @options = options
@@ -249,7 +263,7 @@ module ActiveFedora
     class AssociationReflection < MacroReflection #:nodoc:
       attr_accessor :parent_reflection # Reflection
 
-      def initialize(macro, name, scope, options, active_fedora)
+      def initialize(name, scope, options, active_fedora)
         super
         @constructable = calculate_constructable(macro, options)
       end
@@ -300,13 +314,6 @@ module ActiveFedora
       end
       alias chain collect_join_chain # todo
 
-      # Returns whether or not this association reflection is for a collection
-      # association. Returns +true+ if the +macro+ is either +has_many+ or
-      # +has_and_belongs_to_many+, +false+ otherwise.
-      def collection?
-        [:has_many, :has_and_belongs_to_many, :directly_contains, :indirectly_contains].include?(macro)
-      end
-
       def has_inverse?
         inverse_name
       end
@@ -317,6 +324,20 @@ module ActiveFedora
         @inverse_of ||= klass._reflect_on_association inverse_name
       end
 
+      # Returns the macro type.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      def macro
+        raise NotImplementedError
+      end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        false
+      end
+
       # Returns whether or not the association should be validated as part of
       # the parent's validation.
       #
@@ -331,26 +352,7 @@ module ActiveFedora
       end
 
       def association_class
-        case macro
-        when :contains
-          Associations::BasicContainsAssociation
-        when :belongs_to
-          Associations::BelongsToAssociation
-        when :has_and_belongs_to_many
-          Associations::HasAndBelongsToManyAssociation
-        when :has_many
-          Associations::HasManyAssociation
-        when :singular_rdf
-          Associations::SingularRDF
-        when :rdf
-          Associations::RDF
-        when :directly_contains
-          Associations::DirectlyContainsAssociation
-        when :directly_contains_one
-          Associations::DirectlyContainsOneAssociation
-        when :indirectly_contains
-          Associations::IndirectlyContainsAssociation
-        end
+        raise NotImplementedError
       end
 
       VALID_AUTOMATIC_INVERSE_MACROS = [:has_many, :has_and_belongs_to_many, :belongs_to].freeze
@@ -358,15 +360,15 @@ module ActiveFedora
 
       # Returns +true+ if +self+ is a +belongs_to+ reflection.
       def belongs_to?
-        macro == :belongs_to
+        false
       end
 
       def has_many?
-        macro == :has_many
+        false
       end
 
       def has_and_belongs_to_many?
-        macro == :has_and_belongs_to_many
+        false
       end
 
       private
@@ -451,12 +453,122 @@ module ActiveFedora
         end
     end
 
+    class HasManyReflection < AssociationReflection # :nodoc:
+      def macro
+        :has_many
+      end
+
+      def collection?
+        true
+      end
+
+      def has_many?
+        true
+      end
+
+      def association_class
+        Associations::HasManyAssociation
+      end
+    end
+
+    class BelongsToReflection < AssociationReflection # :nodoc:
+      def macro
+        :belongs_to
+      end
+
+      def belongs_to?
+        true
+      end
+
+      def association_class
+        Associations::BelongsToAssociation
+      end
+    end
+
+    class HasAndBelongsToManyReflection < AssociationReflection # :nodoc:
+      def macro
+        :has_and_belongs_to_many
+      end
+
+      def collection?
+        true
+      end
+
+      def has_and_belongs_to_many?
+        true
+      end
+
+      def association_class
+        Associations::HasAndBelongsToManyAssociation
+      end
+    end
+
+    class ContainsReflection < AssociationReflection # :nodoc:
+      def macro
+        :contains
+      end
+
+      def association_class
+        Associations::BasicContainsAssociation
+      end
+    end
+
+    class DirectlyContainsReflection < AssociationReflection # :nodoc:
+      def macro
+        :directly_contains
+      end
+
+      def collection?
+        true
+      end
+
+      def association_class
+        Associations::DirectlyContainsAssociation
+      end
+    end
+
+    class DirectlyContainsOneReflection < AssociationReflection # :nodoc:
+      def macro
+        :directly_contains_one
+      end
+
+      def association_class
+        Associations::DirectlyContainsOneAssociation
+      end
+    end
+
+    class IndirectlyContainsReflection < AssociationReflection # :nodoc:
+      def macro
+        :indirectly_contains
+      end
+
+      def collection?
+        true
+      end
+
+      def association_class
+        Associations::IndirectlyContainsAssociation
+      end
+    end
+
     class RDFPropertyReflection < AssociationReflection
       def initialize(*args)
         super
         active_fedora.index_config[name] = build_index_config
       end
 
+      def macro
+        :rdf
+      end
+
+      def association_class
+        Associations::RDF
+      end
+
+      def collection?
+        true
+      end
+
       def derive_foreign_key
         name
       end
@@ -473,5 +585,66 @@ module ActiveFedora
           ActiveFedora::Indexing::Map::IndexObject.new(predicate_for_solr) { |index| index.as :symbol }
         end
     end
+
+    class SingularRDFPropertyReflection < RDFPropertyReflection
+      def macro
+        :singular_rdf
+      end
+
+      def collection?
+        false
+      end
+
+      def association_class
+        Associations::SingularRDF
+      end
+    end
+
+    class FilterReflection < AssociationReflection
+      def macro
+        :filter
+      end
+
+      def association_class
+        Associations::FilterAssociation
+      end
+
+      # delegates to extending_from
+      delegate :klass, to: :extending_from
+
+      def extending_from
+        @extending_from ||= active_fedora._reflect_on_association(options.fetch(:extending_from))
+      end
+
+      def collection?
+        true
+      end
+    end
+
+    class OrdersReflection < AssociationReflection
+      def macro
+        :orders
+      end
+
+      def association_class
+        Associations::OrdersAssociation
+      end
+
+      def collection?
+        true
+      end
+
+      def class_name
+        klass.to_s
+      end
+
+      def unordered_reflection
+        options[:unordered_reflection]
+      end
+
+      def klass
+        ActiveFedora::Orders::ListNode
+      end
+    end
   end
 end