activefedora-aggregation 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc7b80996e579a5e5799166881384286103a4f9f
-  data.tar.gz: 043ff54398c18eee3edffb4cea5ecafea8bf584b
+  metadata.gz: 3e412a6567468dcb49dab1daa8bc699ea2205812
+  data.tar.gz: e41e914e33fc66e39fcb2b64fdd528d41364a8ee
 SHA512:
-  metadata.gz: 9cf9b0d7bb610199dcdd21472ee9e20ce4a0cdd1301166d8f43ff7e03826e27c2fc32a29f841b16f6fb12f0ceaab0f92e7bf4d08d6ad8bb85e223c71603f7405
-  data.tar.gz: 673692c667c8204105cbea4041c95728afd5d07ee80723ae389bdfa8d75c9f0e432a5139e9d6b7d9e6a98146e3da12df2cbe0e2c15e3e46d9a65ec50b5528651
+  metadata.gz: 52481ea56a4dec434bd0da1affc85137d9212db3832fcce27cfaf24ac300393ff31fdb26eb0f0385d0c7f52fe044df2fff3e26f1d6e12458e77a1e66e122c0e9
+  data.tar.gz: 429d9ec648f2391f8a013bb3a459c5e78f3cdcd972d0ed85fe15f71c1ee1f14bf2d959476085545c7980854f11f712150df7b99c2bb2ccce5173f10aee88b247

data/README.md

@@ -15,15 +15,30 @@ end
 
 generic_file1 = GenericFile.create(id: 'file1')
 generic_file2 = GenericFile.create(id: 'file2')
+generic_file3 = GenericFile.create(id: 'file2')
 
 class Image < ActiveFedora::Base
-  aggregates :generic_files
+  ordered_aggregation :generic_files, through: :list_source
 end
 
 image = Image.create(id: 'my_image')
-image.generic_files = [generic_file2, generic_file1]
+image.ordered_generic_file_proxies.append_target generic_file2
+image.ordered_generic_file_proxies.append_target generic_file1
 image.save
-
+image.generic_files # => [generic_file2, generic_file]
+image.ordered_generic_files # => [generic_file2, generic_file]
+
+# Not all generic files must be ordered.
+image.generic_files += [generic_file3]
+image.generic_files # => [generic_file2, generic_file, generic_file3]
+image.ordered_generic_files # => [generic_file2, generic_file]
+
+# non-ordered accessor is not ordered.
+image.ordered_generic_file_proxies.insert_at(0, generic_file3)
+image.generic_files # => [generic_file2, generic_file, generic_file3]
+image.ordered_generic_files # => [generic_file3, generic_file2, generic_file]
+
+# Deletions
+image.ordered_generic_file_proxies.delete_at(1)
+image.ordered_generic_files # => [generic_file3, generic_file]
 ```
-
-Now the `generic_files` method returns an ordered list of GenericFile objects.

data/activefedora-aggregation.gemspec

@@ -17,8 +17,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency 'activesupport'
-  spec.add_dependency 'active-fedora'
+  spec.add_dependency 'active-fedora', '~> 9.5'
   spec.add_dependency 'rdf-vocab', '~> 0.8.1'
+  # Lock to RDF 1.1.16 because 1.1.17 causes a bug from ruby 2.2
+  # https://github.com/ruby-rdf/rdf/pull/213
+  spec.add_dependency 'rdf', '~>1.1.16.0'
 
   spec.add_development_dependency "bundler", "~> 1.8"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/active_fedora/aggregation/association.rb

@@ -3,7 +3,7 @@ module ActiveFedora::Aggregation
     delegate :first, to: :ordered_reader
 
     def ordered_reader
-      OrderedReader.new(owner).to_a
+      OrderedReader.new(owner).to_a.map(&:target)
     end
 
     def proxy_class

data/lib/active_fedora/aggregation/base_extension.rb

@@ -12,11 +12,25 @@ module ActiveFedora::Aggregation
       #   https://jira.duraspace.org/browse/FCREPO-1497
       # so we have to look up the proxies asserting RDF::Vocab::ORE.proxyFor
       # and return their containers.
+      return [] unless id
       proxy_class.where(proxyFor_ssim: id).map(&:container)
     end
 
+    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
+
       def proxy_class
         ActiveFedora::Aggregation::Proxy
       end
@@ -32,6 +46,28 @@ module ActiveFedora::Aggregation
         Builder.build(self, name, options)
       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={})
+        ActiveFedora::Orders::Builder.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={})
+        ActiveFedora::Orders::AggregationBuilder.build(self, name, options)
+      end
+
       ##
       # Create an association filter on the class
       # @example
@@ -54,6 +90,10 @@ module ActiveFedora::Aggregation
           ActiveFedora::Filter::Reflection.new(macro, name, options, active_fedora).tap do |reflection|
             add_reflection name, reflection
           end
+        when :orders
+          ActiveFedora::Orders::Reflection.new(macro, name, options, active_fedora).tap do |reflection|
+            add_reflection name, reflection
+          end
         else
           super
         end

data/lib/active_fedora/aggregation/list_source.rb

@@ -0,0 +1,86 @@
+module ActiveFedora
+  module Aggregation
+    class ListSource < ActiveFedora::Base
+      property :head, predicate: ::RDF::Vocab::IANA['first'], multiple: false
+      property :tail, predicate: ::RDF::Vocab::IANA.last, multiple: false
+      property :nodes, predicate: ::RDF::DC::hasPart
+
+      def save(*args)
+        return true if has_unpersisted_proxy_for? || !changed?
+        persist_ordered_self if ordered_self.changed?
+        super
+      end
+
+      def changed?
+        super || ordered_self.changed?
+      end
+
+      # Ordered list representation of proxies in graph.
+      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.
+      def ordered_self=(new_ordered_self)
+        @ordered_self = new_ordered_self
+      end
+
+      # 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)
+        options ||= {}
+        options[:except] ||= []
+        options[:except] += [:head, :tail, :nodes]
+        super
+      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
+
+      private
+
+      def persist_ordered_self
+        nodes_will_change!
+        # Delete old statements
+        ordered_list_factory.new(resource, head_subject, tail_subject).to_graph.statements.each do |s|
+          resource.delete s
+        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.flat_map(&:target).compact.select(&:new_record?).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

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

data/lib/active_fedora/aggregation/version.rb

@@ -1,5 +1,5 @@
 module ActiveFedora
   module Aggregation
-    VERSION = "0.4.2"
+    VERSION = "0.5.0"
   end
 end

data/lib/active_fedora/aggregation.rb

@@ -3,6 +3,7 @@ require 'active_support'
 require 'active-fedora'
 require 'rdf/vocab'
 require 'active_fedora/filter'
+require 'active_fedora/orders'
 
 module ActiveFedora
   module Aggregation
@@ -25,6 +26,7 @@ module ActiveFedora
       autoload :DecoratorWithArguments
       autoload :DecoratorList
       autoload :ProxyRepository
+      autoload :ListSource
     end
 
     ActiveFedora::Base.include BaseExtension

data/lib/active_fedora/orders/aggregation_builder.rb

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

data/lib/active_fedora/orders/association.rb

@@ -0,0 +1,133 @@
+module ActiveFedora::Orders
+  class Association < ::ActiveFedora::Associations::CollectionAssociation
+
+    def initialize(*args)
+      super
+      @target = find_target
+    end
+
+    def reader(*args)
+      @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 ||= TargetProxy.new(self)
+    end
+
+    def find_reflection
+      reflection
+    end
+
+    def replace(new_ordered_list)
+      raise unless new_ordered_list.kind_of? 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, &block)
+      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)
+    end
+
+    # Delete whatever node is at a specific position
+    # @param [Integer] loc Position to delete
+    def delete_at(loc)
+      target.delete_at(loc)
+    end
+
+    # 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(ordered_reflection_name)
+    end
+
+    def ordered_reflection_name
+      reflection.ordered_reflection.name
+    end
+  end
+end

data/lib/active_fedora/orders/builder.rb

@@ -0,0 +1,43 @@
+module ActiveFedora::Orders
+  class Builder < ActiveFedora::Associations::Builder::CollectionAssociation
+    include ActiveFedora::AutosaveAssociation::AssociationBuilderExtension
+    self.macro = :orders
+    self.valid_options += [:through, :ordered_reflection]
+
+    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 initialize(model, name, options)
+      @original_name = name
+      @model = model
+      name = :"ordered_#{name.to_s.singularize}_proxies"
+      options = {ordered_reflection: ordered_reflection}.merge(options)
+      super
+    end
+
+    def build
+      super.tap do
+        model.property :head, predicate: ::RDF::Vocab::IANA['first']
+        model.property :tail, predicate: ::RDF::Vocab::IANA.last
+      end
+    end
+
+    private
+
+    def self.target_accessor(name)
+      name.to_s.gsub("_proxies","").pluralize
+    end
+
+    def ordered_reflection
+      model.reflect_on_association(@original_name)
+    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, :delete_at, to: :association
+    end
+  end
+end

data/lib/active_fedora/orders/list_node.rb

@@ -0,0 +1,157 @@
+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.try(:uri)
+      g.proxy_in = proxy_in.try(:uri)
+      g.next = self.next.try(:rdf_subject)
+      g.prev = self.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_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

data/lib/active_fedora/orders/ordered_list.rb

@@ -0,0 +1,253 @@
+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 -(nodes)
+        nodes.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)
+        node = build_node(new_node_subject)
+        node.target = target
+        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
+        end
+        self
+      end
+
+      # @param [Integer] loc Index of node to delete.
+      def delete_at(loc)
+        return self if loc == nil
+        arr = ordered_reader.take(loc+1)
+        if arr.length == loc+1
+          delete_node(arr.last)
+        else
+          self
+        end
+      end
+
+      # @return [Boolean] Whether this list was changed since instantiation.
+      def changed?
+        @changed
+      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.has_key?(node)
+          node = ::RDF::URI("##{::RDF::Node.new.id}")
+        end
+        node
+      end
+
+      class NodeCache
+        def initialize
+          @cache ||= {}
+        end
+
+        def fetch(uri)
+          if @cache[uri]
+            @cache[uri]
+          else
+            if block_given?
+              @cache[uri] = yield
+            end
+          end
+        end
+
+        def has_key?(key)
+          @cache.has_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
+
+        def next
+          @next
+        end
+
+        def prev
+          @prev
+        end
+
+        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
+          if prev && prev.next != self
+            prev.next = self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_fedora/orders/reflection.rb

@@ -0,0 +1,24 @@
+module ActiveFedora::Orders
+  class Reflection < ActiveFedora::Reflection::AssociationReflection
+    def association_class
+      Association
+    end
+
+    def collection?
+      true
+    end
+
+    def class_name
+      klass.to_s
+    end
+
+    def ordered_reflection
+      options[:ordered_reflection]
+    end
+
+    def klass
+      ActiveFedora::Orders::ListNode
+    end
+  end
+end
+

data/lib/active_fedora/orders/target_proxy.rb

@@ -0,0 +1,43 @@
+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 clear
+        while to_ary.present?
+          association.delete_at(0)
+        end
+      end
+
+      def to_ary
+        association.reader.map(&:target).dup
+      end
+      alias_method :to_a, :to_ary
+
+      def ==(other_obj)
+        case other_obj
+        when TargetProxy
+          super
+        when Array
+          to_a == other_obj
+        end
+      end
+    end
+  end
+end

data/lib/active_fedora/orders.rb

@@ -0,0 +1,16 @@
+module ActiveFedora
+  module Orders
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :AggregationBuilder
+      autoload :Association
+      autoload :Builder
+      autoload :CollectionProxy
+      autoload :Reflection
+      autoload :ListNode
+      autoload :OrderedList
+      autoload :TargetProxy
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activefedora-aggregation
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Justin Coyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-09 00:00:00.000000000 Z
+date: 2015-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -28,16 +28,16 @@ dependencies:
   name: active-fedora
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '9.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '9.5'
 - !ruby/object:Gem::Dependency
   name: rdf-vocab
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.16.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -152,6 +166,7 @@ files:
 - lib/active_fedora/aggregation/decorator_list.rb
 - lib/active_fedora/aggregation/decorator_with_arguments.rb
 - lib/active_fedora/aggregation/link_inserter.rb
+- lib/active_fedora/aggregation/list_source.rb
 - lib/active_fedora/aggregation/null_proxy.rb
 - lib/active_fedora/aggregation/ordered_proxy.rb
 - lib/active_fedora/aggregation/ordered_reader.rb
@@ -165,6 +180,15 @@ files:
 - lib/active_fedora/filter/association.rb
 - lib/active_fedora/filter/builder.rb
 - lib/active_fedora/filter/reflection.rb
+- lib/active_fedora/orders.rb
+- lib/active_fedora/orders/aggregation_builder.rb
+- lib/active_fedora/orders/association.rb
+- lib/active_fedora/orders/builder.rb
+- lib/active_fedora/orders/collection_proxy.rb
+- lib/active_fedora/orders/list_node.rb
+- lib/active_fedora/orders/ordered_list.rb
+- lib/active_fedora/orders/reflection.rb
+- lib/active_fedora/orders/target_proxy.rb
 homepage: http://github.org/curationexperts/activefedora-aggregation
 licenses:
 - APACHE2