activefedora-aggregation 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eaf698c46d501172f3b2db824f2349612a7fb1e5
-  data.tar.gz: abef6dc0592da76db879e6909f4b171c59b6dcdb
+  metadata.gz: e6accff4705ce11b36750f93b831e532f7276e1c
+  data.tar.gz: f603f7707698d4ca8b239da7f3f8dd489cdb0a58
 SHA512:
-  metadata.gz: bbc6ee9983e47539e1908376659b976e4d98b0711f76a35941e0efdb497ba3367ce006aa06857134f6d300480b20344b915667dd5b3fb961f9e5223da5ee8f46
-  data.tar.gz: 20b7af1f37c2ebcc843d32b967caa077ed0f8f312823ae5e3998cf8fa4c2324731e02fb26a1a7e20e3a8464571f0db0cc8db3713f86377b0e6c6788b1749753c
+  metadata.gz: 76293d09bec958fb7a1a645806d2736d62d184cd0a27d38a12cd380db2f2cca49b9ba9e0eb9d1d9432e383738afd70580f14b83a00dc826b1755309cfb00598a
+  data.tar.gz: 045f5653e592fc45e9ae62b3da06ef2d4d9cbeb70fabd2f0aa5fe27aa3e1f8a2a6e6e835b2ac79dd3f59e43d73a14b044adde6dc06690b0e485059478c9f922b

data/Gemfile

@@ -3,4 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in activefedora-aggregation.gemspec
 gemspec
 gem 'byebug' unless ENV['CI']
-
+gem 'active-fedora', github: "projecthydra/active_fedora"

data/README.md

@@ -1,4 +1,4 @@
-[![Gem Version](https://badge.fury.io/rb/activefedora-aggregation.svg)](http://badge.fury.io/rb/activefedora-aggregation) [![Build Status](https://travis-ci.org/curationexperts/activefedora-aggregation.svg?branch=v0.1.0)](https://travis-ci.org/curationexperts/activefedora-aggregation)
+[![Gem Version](https://badge.fury.io/rb/activefedora-aggregation.svg)](http://badge.fury.io/rb/activefedora-aggregation) [![Build Status](https://circleci.com/gh/projecthydra-labs/activefedora-aggregation.svg?style=shield&circle-token=:circle-token)](https://circleci.com/gh/projecthydra-labs/activefedora-aggregation)
 # ActiveFedora::Aggregation
 
 Aggregations for ActiveFedora.
@@ -21,35 +21,4 @@ image.save
 
 ```
 
-Now the "generic\_files" method returns an ordered list of GenericFile objects.
-
-Here's what the graph looks like:
-
-```ttl
-<http://127.0.0.1:8983/fedora/rest/dev/my_image> a <http://www.w3.org/ns/ldp#RDFSource>,
-     <http://www.w3.org/ns/ldp#Container>;
-   <http://www.w3.org/ns/ldp#contains> <http://127.0.0.1:8983/fedora/rest/dev/my_image/files>;
-   <info:fedora/fedora-system:def/model#hasModel> "Image" .
-
-<http://127.0.0.1:8983/fedora/rest/dev/my_image/files> a <http://www.w3.org/ns/ldp#RDFSource>,
-     <http://www.w3.org/ns/ldp#Container>;
-   <http://www.iana.org/assignments/relation/first> <http://127.0.0.1:8983/fedora/rest/dev/my_image/files/5a5af870-594b-4966-93f6-0348402583f0>;
-   <http://www.iana.org/assignments/relation/last> <http://127.0.0.1:8983/fedora/rest/dev/my_image/files/9cc70b3d-c9d7-4cfc-b504-adbcb0bdfb3d>;
-   <http://www.w3.org/ns/ldp#contains> <http://127.0.0.1:8983/fedora/rest/dev/my_image/files/5a5af870-594b-4966-93f6-0348402583f0>,
-     <http://127.0.0.1:8983/fedora/rest/dev/my_image/files/9cc70b3d-c9d7-4cfc-b504-adbcb0bdfb3d>;
-   <info:fedora/fedora-system:def/model#hasModel> "ActiveFedora::Aggregation::ProxyContainer" .
-
-<http://127.0.0.1:8983/fedora/rest/dev/my_image/files/5a5af870-594b-4966-93f6-0348402583f0> a <http://www.w3.org/ns/ldp#RDFSource>,
-     <http://www.w3.org/ns/ldp#Container>;
-   <http://www.iana.org/assignments/relation/next> <http://127.0.0.1:8983/fedora/rest/dev/my_image/files/9cc70b3d-c9d7-4cfc-b504-adbcb0bdfb3d>;
-   <http://www.openarchives.org/ore/terms/proxyFor> <http://127.0.0.1:8983/fedora/rest/dev/file2>;
-   <http://www.openarchives.org/ore/terms/proxyIn> <http://127.0.0.1:8983/fedora/rest/dev/my_image/files>;
-   <info:fedora/fedora-system:def/model#hasModel> "ActiveFedora::Aggregation::Proxy" .
-
-<http://127.0.0.1:8983/fedora/rest/dev/my_image/files/9cc70b3d-c9d7-4cfc-b504-adbcb0bdfb3d> a <http://www.w3.org/ns/ldp#RDFSource>,
-     <http://www.w3.org/ns/ldp#Container>;
-   <http://www.iana.org/assignments/relation/prev> <http://127.0.0.1:8983/fedora/rest/dev/my_image/files/5a5af870-594b-4966-93f6-0348402583f0>;
-   <http://www.openarchives.org/ore/terms/proxyFor> <http://127.0.0.1:8983/fedora/rest/dev/file1>;
-   <http://www.openarchives.org/ore/terms/proxyIn> <http://127.0.0.1:8983/fedora/rest/dev/my_image/files>;
-   <info:fedora/fedora-system:def/model#hasModel> "ActiveFedora::Aggregation::Proxy" .
-```
+Now the `generic\_files` method returns an ordered list of GenericFile objects.

data/Rakefile

@@ -6,7 +6,7 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
 require 'jettywrapper'
-Jettywrapper.hydra_jetty_version = "v8.3.0"
+Jettywrapper.hydra_jetty_version = "v8.3.1"
 
 desc 'Spin up hydra-jetty and run specs'
 task ci: ['jetty:clean'] do

data/activefedora-aggregation.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.2"
   spec.add_development_dependency "jettywrapper"
+  spec.add_development_dependency "pry-byebug"
 end

data/bin/jetty_wait

@@ -0,0 +1,6 @@
+#!/usr/bin/env sh
+
+until $(curl --output /dev/null --silent --head --fail http://localhost:8983/solr); do
+    printf '.'
+    sleep 1
+done

data/circle.yml

@@ -0,0 +1,11 @@
+machine:
+  ruby:
+    version: 2.2.0
+dependencies:
+  pre:
+    - gem install bundler
+  post:
+    - bundle exec rake jetty:clean
+    - cd jetty && java -Djetty.port=8983 -Dsolr.solr.home=/home/ubuntu/activefedora-aggregation/jetty/solr -XX:MaxPermSize=128m -Xmx256m -jar start.jar:
+        background: true
+    - bin/jetty_wait

data/lib/active_fedora/aggregation/aggregation_extension.rb

@@ -0,0 +1,26 @@
+# This module is mixed into classes that declare 'aggregates ...'
+#
+module ActiveFedora::Aggregation
+  module AggregationExtension
+    extend ActiveSupport::Concern
+    include PersistLinks
+
+    included do
+      after_destroy :remove_aggregation_proxies_from_solr
+
+      # Doesn't use after_save because we need this callback to come after the autosave callback
+      after_create :persist_aggregation_links
+      after_update :persist_aggregation_links
+    end
+
+    private
+
+      # The proxies, being nested under the object, are automatically destroyed
+      # this cleans up their records from solr.
+      def remove_aggregation_proxies_from_solr
+        query = ActiveFedora::SolrQueryBuilder.construct_query_for_rel(proxyIn: id, has_model: Proxy.to_class_uri)
+        ActiveFedora::SolrService.instance.conn.delete_by_query(query, params: {'softCommit' => true})
+      end
+
+  end
+end

data/lib/active_fedora/aggregation/appends_to_aggregation.rb

@@ -0,0 +1,31 @@
+module ActiveFedora::Aggregation
+  class AppendsToAggregation < SimpleDelegator
+    attr_reader :parent_node
+    # @param [#next, #prev] proxy The proxy to add behavior to.
+    # @param [#head, #tail] parent_node The aggregation to append proxies to.
+    def initialize(proxy, parent_node)
+      @parent_node = parent_node
+      super(proxy)
+    end
+
+    def is_a?(klass)
+      __getobj__.is_a?(klass)
+    end
+
+    def save(*args)
+      insert_link do
+        super
+      end
+    end
+
+    private
+
+    def insert_link
+      result = yield
+      if result
+        LinkInserter.new(parent_node, self).call
+      end
+      result
+    end
+  end
+end

data/lib/active_fedora/aggregation/association.rb

@@ -1,59 +1,84 @@
 module ActiveFedora::Aggregation
-  class Association
+  class Association < ::ActiveFedora::Associations::IndirectlyContainsAssociation
+    delegate :first, to: :ordered_reader
 
-    # @param [ActiveFedora::Base] parent
-    # @param [Reflection] reflection
-    # @opts options [String] class_name name of the class in the association
-    def initialize(parent, reflection)
-      @parent = parent
-      @reflection = reflection
+    def ordered_reader
+      OrderedReader.new(owner).to_a
     end
 
-    def klass
-      @reflection.klass
+    def proxy_class
+      @proxy_class ||= ProxyRepository.new(owner, super)
     end
 
-    def == other
-      container.to_a == other
+    def options
+      @all_options ||= default_options.merge(super)
     end
 
-    def create(&block)
-      klass.create(&block).tap do |created|
-        container << created
+    # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
+    def ids_reader
+      if loaded?
+        load_target.map do |record|
+          record.id
+        end
+      else
+        proxies = load_proxies_from_solr(fl: 'id, next_ssim, proxyFor_ssim')
+        create_linked_list(@owner.head_id, proxies)
       end
-      save #causes the (head/tail) pointers on the aggregation to be persisted
     end
 
-    def save
-      container.save
+    private
+
+    # Write a query to find the proxies
+    def construct_proxy_query
+      @proxy_query ||= begin
+        clauses = { 'proxyIn' => @owner.id }
+        clauses[:has_model] = ActiveFedora::Aggregation::Proxy.to_class_uri
+        ActiveFedora::SolrQueryBuilder.construct_query_for_rel(clauses)
+      end
     end
 
-    def target=(vals)
-      container.target=(vals)
+    # Finds the proxies
+    # @param opts [Hash] Options that will be passed through to ActiveFedora::SolrService.query.
+    def load_proxies_from_solr(opts = Hash.new)
+      finder_query = construct_proxy_query
+      rows = 1000
+      ActiveFedora::SolrService.query(finder_query, { rows: rows }.merge(opts))
     end
 
-    def target_ids=(vals)
-      container.target_ids=(vals)
+    # @param [String, NilClass] first_id
+    # @param [Array<Hash>] remainder
+    # @param [Array] list
+    def create_linked_list(first_id, remainder, list=[])
+      return list if remainder.empty?
+
+      index = remainder.find_index { |n| n.fetch('id') == first_id }
+      first = remainder.delete_at(index)
+      next_id = first['next_ssim'].try(:first)
+      create_linked_list(next_id, remainder, list + [first.fetch('proxyFor_ssim').first])
     end
 
-    def target_ids
-      container.target_ids
+    def default_options
+      { through: default_proxy_class, foreign_key: :target, has_member_relation: reflection.predicate, inserted_content_relation: content_relation }
     end
 
-    def container
-      @container ||= begin
-         ProxyContainer.find_or_initialize(klass.uri_to_id(uri)).tap do |container|
-           container.parent = @parent
-         end
-      end
+    def content_relation
+      default_proxy_class.constantize.reflect_on_association(:target).predicate
     end
 
-    def first
-      container.first
+    def default_proxy_class
+      'ActiveFedora::Aggregation::Proxy'
     end
 
-    def uri
-      @parent.uri + '/files'
+    def raise_on_type_mismatch(record)
+      super
+      if type_validator
+        type_validator.validate!(self,record)
+      end
+    end
+
+    def type_validator
+      options[:type_validator]
     end
+
   end
 end

data/lib/active_fedora/aggregation/base_extension.rb

@@ -1,23 +1,62 @@
 module ActiveFedora::Aggregation
   module BaseExtension
+    extend ActiveSupport::Concern
 
-    ##
-    # Create an aggregation association on the class
-    # @example
-    #   class Image < ActiveFedora::Base
-    #     aggregates :generic_files
-    #   end
-    def aggregates(name, options={})
-      Builder.build(self, name, options)
+    # Queries the RDF graph to find all records that include this object in their aggregations
+    # Since any class may be the target of an aggregation, this must be on every class extending
+    # from ActiveFedora::Base
+    # @return [Array] records that include this object in their aggregations
+    def aggregated_by
+      # In theory you should be able to find the aggregation predicate (ie ore:aggregates)
+      # but Fedora does not return that predicate due to this bug in FCREPO:
+      #   https://jira.duraspace.org/browse/FCREPO-1497
+      # so we have to look up the proxies asserting RDF::Vocab::ORE.proxyFor
+      # and return their containers.
+      proxy_class.where(proxyFor_ssim: id).map(&:container)
     end
 
-    def create_reflection(macro, name, options, active_fedora)
-      if macro == :aggregation
-        Reflection.new(macro, name, options, active_fedora).tap do |reflection|
-          add_reflection name, reflection
+    private
+
+      def proxy_class
+        ActiveFedora::Aggregation::Proxy
+      end
+
+    module ClassMethods
+      ##
+      # Create an aggregation association on the class
+      # @example
+      #   class Image < ActiveFedora::Base
+      #     aggregates :generic_files
+      #   end
+      def aggregates(name, options={})
+        Builder.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)
+        ActiveFedora::Filter::Builder.build(self, name, options.merge(extending_from: extending_from))
+      end
+
+      def create_reflection(macro, name, options, active_fedora)
+        case macro
+        when :aggregation
+          Reflection.new(macro, name, options, active_fedora).tap do |reflection|
+            add_reflection name, reflection
+          end
+        when :filter
+          ActiveFedora::Filter::Reflection.new(macro, name, options, active_fedora).tap do |reflection|
+            add_reflection name, reflection
+          end
+        else
+          super
         end
-      else
-        super
       end
     end
   end

data/lib/active_fedora/aggregation/builder.rb

@@ -1,14 +1,17 @@
 module ActiveFedora::Aggregation
   class Builder < ActiveFedora::Associations::Builder::CollectionAssociation
+    include ActiveFedora::AutosaveAssociation::AssociationBuilderExtension
     self.macro = :aggregation
+    self.valid_options += [
+      :type_validator
+    ]
 
     def build
       reflection = super
-      configure_dependency
-      model.has_and_belongs_to_many :proxies, predicate: ::RDF::Vocab::ORE.aggregates, class_name: 'ActiveFedora::Aggregation::Proxy', inverse_of: :containers
       model.belongs_to :head, predicate: ::RDF::Vocab::IANA['first'], class_name: 'ActiveFedora::Aggregation::Proxy'
       model.belongs_to :tail, predicate: ::RDF::Vocab::IANA.last, class_name: 'ActiveFedora::Aggregation::Proxy'
 
+      model.include AggregationExtension
       reflection
     end
 
@@ -17,6 +20,9 @@ module ActiveFedora::Aggregation
       mixin.redefine_method("#{name.to_s.singularize}_ids") do
         association(name).ids_reader
       end
+      mixin.redefine_method("ordered_#{name.to_s.pluralize}") do
+        association(name).ordered_reader
+      end
     end
 
     def self.define_writers(mixin, name)
@@ -26,23 +32,5 @@ module ActiveFedora::Aggregation
       end
     end
 
-    private
-
-      def configure_dependency
-        define_save_dependency_method
-        model.after_save dependency_method_name
-      end
-
-      def define_save_dependency_method
-        name = self.name
-        model.send(:define_method, dependency_method_name) do
-          send(name).save
-        end
-      end
-
-      def dependency_method_name
-        "aggregator_dependent_for_#{name}"
-      end
-
   end
 end

data/lib/active_fedora/aggregation/decorating_repository.rb

@@ -0,0 +1,29 @@
+module ActiveFedora::Aggregation
+  ##
+  # Decorates the results of a repository with the given decorator.
+  class DecoratingRepository < SimpleDelegator
+    attr_reader :decorator
+    # @param [#new] decorator A decorator.
+    # @param [#find, #new] base_repository A repository to decorate.
+    def initialize(decorator, base_repository)
+      @decorator = decorator
+      super(base_repository)
+    end
+
+    def find(id)
+      decorate(super(id))
+    end
+
+    def new(*args)
+      result = decorate(super(*args))
+      yield result if block_given?
+      result
+    end
+
+    private
+
+    def decorate(obj)
+      decorator.new(obj)
+    end
+  end
+end

data/lib/active_fedora/aggregation/decorator_list.rb

@@ -0,0 +1,15 @@
+module ActiveFedora::Aggregation
+  # A composite object to allow for a list of decorators to be treated like one.
+  class DecoratorList
+    attr_reader :decorators
+    def initialize(*decorators)
+      @decorators = decorators
+    end
+
+    def new(undecorated_object)
+      decorators.inject(undecorated_object) do |obj, decorator|
+        decorator.new(obj)
+      end
+    end
+  end
+end

data/lib/active_fedora/aggregation/decorator_with_arguments.rb

@@ -0,0 +1,15 @@
+module ActiveFedora::Aggregation
+  # This is an Adapter to allow a Decorator to respond to the interface #new()
+  # but still require other arguments to instantiate.
+  class DecoratorWithArguments
+    attr_reader :decorator, :args
+    def initialize(decorator, *args)
+      @decorator = decorator
+      @args = args
+    end
+
+    def new(obj)
+      decorator.new(obj, *args)
+    end
+  end
+end

data/lib/active_fedora/aggregation/link_inserter.rb

@@ -0,0 +1,56 @@
+module ActiveFedora::Aggregation
+  class LinkInserter
+    attr_reader :root, :proxy
+    # @param [ProxyOwner] root the node representing the aggregation
+    # @param [Proxy] proxy the proxy to add to the aggregation
+    def initialize(root, proxy)
+      @root = root
+      @proxy = proxy
+    end
+
+    def call
+      if root.head
+        append
+      else
+        set
+      end
+      proxy.container = root
+      persist_nodes!
+    end
+
+    private
+
+    def append
+      Appender.new(root, proxy).call
+    end
+
+    def set
+      root.head = proxy
+      root.tail = proxy
+    end
+
+    def persist_nodes!
+      [proxy, proxy.prev].uniq.compact.each(&:save!)
+    end
+
+    class Appender
+      attr_reader :root, :proxy
+      def initialize(root, proxy)
+        @root = root
+        @proxy = proxy
+      end
+
+      def call
+        last_proxy.next = proxy
+        proxy.prev = last_proxy
+        root.tail = proxy
+      end
+
+      private
+
+      def last_proxy
+        @last_proxy ||= root.tail
+      end
+    end
+  end
+end

data/lib/active_fedora/aggregation/null_proxy.rb

@@ -0,0 +1,23 @@
+module ActiveFedora::Aggregation
+  # A null proxy to simplify logic.
+  class NullProxy
+    include Singleton
+
+    attr_writer :prev, :next
+    def prev
+      self
+    end
+
+    def next
+      self
+    end
+
+    def reload
+      self
+    end
+
+    def changed?
+      false
+    end
+  end
+end

data/lib/active_fedora/aggregation/ordered_proxy.rb

@@ -0,0 +1,57 @@
+module ActiveFedora::Aggregation
+  # A proxy which knows how to delete itself from an aggregation.
+  class OrderedProxy < SimpleDelegator
+    attr_reader :parent_node
+    # @param [#next, #prev, #delete] proxy The proxy to add behavior to.
+    # @param [#delete_proxy!] parent_node The aggregation to delete proxies
+    #   from.
+    def initialize(proxy, parent_node)
+      @parent_node = parent_node
+      super(proxy)
+    end
+
+    def is_a?(klass)
+      __getobj__.is_a?(klass)
+    end
+
+    def delete(*args)
+      link_node_if_true do
+        super
+      end
+    end
+
+    protected
+
+    def link_node_if_true
+      # Have to precache these or AF tries to access this node?
+      next_or_null
+      prev_or_null
+      yield.tap do |result|
+        if result
+          # Have to reload proxies because otherwise you persist them with bad
+          # referencing triples.
+          [next_or_null, prev_or_null, parent_node].each(&:reload)
+          prev_or_null.next = self.next
+          next_or_null.prev = prev
+          changed_nodes.each(&:save!)
+          parent_node.delete_proxy!(self)
+        end
+      end
+    end
+
+    def next_or_null
+      self.next || NullProxy.instance
+    end
+
+    def prev_or_null
+      self.prev || NullProxy.instance
+    end
+
+    private
+
+    def changed_nodes
+      [self.prev, self.next].uniq.compact.select(&:changed?)
+    end
+
+  end
+end

data/lib/active_fedora/aggregation/ordered_reader.rb

@@ -0,0 +1,23 @@
+module ActiveFedora::Aggregation
+  class OrderedReader
+    include Enumerable
+    attr_reader :root
+    def initialize(root)
+      @root = root
+    end
+
+    def each
+      proxy = first_head
+      while proxy
+        yield proxy.target
+        proxy = proxy.next
+      end
+    end
+
+    private
+
+    def first_head
+      root.head
+    end
+  end
+end

data/lib/active_fedora/aggregation/persist_links.rb

@@ -0,0 +1,9 @@
+module ActiveFedora::Aggregation
+  module PersistLinks
+    # If the head or tail pointer was updated (in an autosave callback), then persist them
+    def persist_aggregation_links
+      return true unless @new_record_before_save
+      save if changes.key?("head_id") or changes.key?("tail_id")
+    end
+  end
+end

data/lib/active_fedora/aggregation/proxy.rb

@@ -1,7 +1,6 @@
 module ActiveFedora::Aggregation
   class Proxy < ActiveFedora::Base
-    # HABTM is actually only belongs to one
-    has_and_belongs_to_many :containers, predicate: ::RDF::Vocab::ORE.proxyIn, class_name: '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'

data/lib/active_fedora/aggregation/proxy_owner.rb

@@ -0,0 +1,24 @@
+module ActiveFedora::Aggregation
+  ##
+  # Decorates a proxy owner such that it knows how to delete a proxy from its
+  # ordered list.
+  class ProxyOwner < SimpleDelegator
+    def is_a?(klass)
+      __getobj__.is_a?(klass)
+    end
+
+    # @param [#next, #prev] proxy A Proxy link to delete.
+    def delete_proxy!(proxy)
+      if proxy == head || head.nil? # Head is nil if proxy is now deleted.
+        self.head = proxy.next
+      end
+      if proxy == tail || tail.nil? # Head is nil if proxy is now deleted.
+        self.tail = proxy.prev
+      end
+      [head, tail].uniq.compact.each(&:reload)
+      if changed?
+        save!
+      end
+    end
+  end
+end

data/lib/active_fedora/aggregation/proxy_repository.rb

@@ -0,0 +1,38 @@
+module ActiveFedora::Aggregation
+  ##
+  # Repository for Proxies. This repository is responsible for decorating a
+  # proxy such that it's useful for aggregation and is an attempt at
+  # centralizing hard-coded dependencies without a dependency injection
+  # container.
+  class ProxyRepository < SimpleDelegator
+    attr_reader :owner, :base_proxy_factory
+    # @param [ActiveFedora::Base] owner The node which proxy will assert order
+    #   on.
+    # @param [#find, #new] base_proxy_factory The base factory which returns proxies
+    #   that will be decorated.
+    # @return [#find, #new] A repository which can return proxies useful for
+    #  aggregation.
+    def initialize(owner, base_proxy_factory)
+      @owner = owner
+      @base_proxy_factory = base_proxy_factory
+      super(repository)
+    end
+
+    private
+
+    def repository
+      DecoratingRepository.new(proxy_decorator, base_proxy_factory)
+    end
+
+    def proxy_decorator
+      DecoratorList.new(
+        DecoratorWithArguments.new(OrderedProxy, proxy_owner),
+        DecoratorWithArguments.new(AppendsToAggregation, proxy_owner)
+      )
+    end
+
+    def proxy_owner
+      @proxy_owner ||= ProxyOwner.new(owner)
+    end
+  end
+end

data/lib/active_fedora/aggregation/reflection.rb

@@ -1,7 +1,24 @@
 module ActiveFedora::Aggregation
   class Reflection < ActiveFedora::Reflection::AssociationReflection
     def association_class
-      ThroughAssociation
+      Association
+    end
+
+    def klass
+      @klass ||= begin
+        klass = class_name.constantize
+        klass.respond_to?(:uri_to_id) ? klass : ActiveFedora::Base
+      rescue NameError => e
+        # If the NameError is a result of the class having a
+        # NameError (e.g. NoMethodError) within it then raise the error.
+        raise e if Object.const_defined? class_name
+        # Otherwise the NameError was a result of not being able to find the class
+        ActiveFedora::Base
+      end
+    end
+
+    def predicate
+      @options[:predicate] || ::RDF::Vocab::ORE.aggregates
     end
 
     def collection?

data/lib/active_fedora/aggregation/version.rb

@@ -1,5 +1,5 @@
 module ActiveFedora
   module Aggregation
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/active_fedora/aggregation.rb

@@ -2,20 +2,31 @@ require 'active_fedora/aggregation/version'
 require 'active_support'
 require 'active-fedora'
 require 'rdf/vocab'
+require 'active_fedora/filter'
 
 module ActiveFedora
   module Aggregation
     extend ActiveSupport::Autoload
     eager_autoload do
-      autoload :ProxyContainer
       autoload :Association
+      autoload :AggregationExtension
       autoload :Proxy
       autoload :Builder
-      autoload :ThroughAssociation
       autoload :Reflection
       autoload :BaseExtension
+      autoload :LinkInserter
+      autoload :OrderedReader
+      autoload :PersistLinks
+      autoload :OrderedProxy
+      autoload :AppendsToAggregation
+      autoload :ProxyOwner
+      autoload :NullProxy
+      autoload :DecoratingRepository
+      autoload :DecoratorWithArguments
+      autoload :DecoratorList
+      autoload :ProxyRepository
     end
 
-    ActiveFedora::Base.extend BaseExtension
+    ActiveFedora::Base.include BaseExtension
   end
 end

data/lib/active_fedora/filter/association.rb

@@ -0,0 +1,70 @@
+module ActiveFedora::Filter
+  class Association < ::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
+
+    def delete(records)
+      extending_from.delete(records)
+    end
+
+    # @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
+
+    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/filter/builder.rb

@@ -0,0 +1,14 @@
+module ActiveFedora::Filter
+  class Builder < ActiveFedora::Associations::Builder::CollectionAssociation
+    self.macro = :filter
+    self.valid_options = [:extending_from, :condition]
+
+    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/filter/reflection.rb

@@ -0,0 +1,21 @@
+module ActiveFedora::Filter
+  class Reflection < ActiveFedora::Reflection::AssociationReflection
+    def association_class
+      Association
+    end
+
+    # delegates to extending_from
+    def klass
+      extending_from.klass
+    end
+
+    def extending_from
+      @extending_from ||= active_fedora.reflect_on_association(options.fetch(:extending_from))
+    end
+
+    def collection?
+      true
+    end
+  end
+end
+

data/lib/active_fedora/filter.rb

@@ -0,0 +1,11 @@
+module ActiveFedora
+  module Filter
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Builder
+      autoload :Reflection
+      autoload :Association
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activefedora-aggregation
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Justin Coyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-11 00:00:00.000000000 Z
+date: 2015-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - justin@curationexperts.com
@@ -125,16 +139,32 @@ files:
 - Rakefile
 - activefedora-aggregation.gemspec
 - bin/console
+- bin/jetty_wait
 - bin/setup
+- circle.yml
 - lib/active_fedora/aggregation.rb
+- lib/active_fedora/aggregation/aggregation_extension.rb
+- lib/active_fedora/aggregation/appends_to_aggregation.rb
 - lib/active_fedora/aggregation/association.rb
 - lib/active_fedora/aggregation/base_extension.rb
 - lib/active_fedora/aggregation/builder.rb
+- lib/active_fedora/aggregation/decorating_repository.rb
+- 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/null_proxy.rb
+- lib/active_fedora/aggregation/ordered_proxy.rb
+- lib/active_fedora/aggregation/ordered_reader.rb
+- lib/active_fedora/aggregation/persist_links.rb
 - lib/active_fedora/aggregation/proxy.rb
-- lib/active_fedora/aggregation/proxy_container.rb
+- lib/active_fedora/aggregation/proxy_owner.rb
+- lib/active_fedora/aggregation/proxy_repository.rb
 - lib/active_fedora/aggregation/reflection.rb
-- lib/active_fedora/aggregation/through_association.rb
 - lib/active_fedora/aggregation/version.rb
+- lib/active_fedora/filter.rb
+- lib/active_fedora/filter/association.rb
+- lib/active_fedora/filter/builder.rb
+- lib/active_fedora/filter/reflection.rb
 homepage: http://github.org/curationexperts/activefedora-aggregation
 licenses:
 - APACHE2
@@ -155,9 +185,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Aggregations for active-fedora
 test_files: []
-has_rdoc: 

data/lib/active_fedora/aggregation/proxy_container.rb

@@ -1,111 +0,0 @@
-module ActiveFedora::Aggregation
-  class ProxyContainer < ActiveFedora::Base
-    type ::RDF::Vocab::LDP.IndirectContainer
-
-    attr_writer :parent
-
-    property :membership_resource, predicate: ::RDF::Vocab::LDP.membershipResource
-    property :member_relation, predicate: ::RDF::Vocab::LDP.hasMemberRelation
-    property :inserted_content_relation, predicate: ::RDF::Vocab::LDP.insertedContentRelation
-
-    after_initialize :default_relations
-
-    def parent
-      @parent || raise("Parent hasn't been set on #{self.class}")
-    end
-
-    def default_relations
-      self.member_relation = [::RDF::URI.new("http://pcdm.org/hasMember")] # TODO wrong predicate!
-      self.inserted_content_relation = [::RDF::Vocab::ORE.proxyFor]
-    end
-
-    def first
-      parent.head.target
-    end
-
-    # This can be a very expensive operation. avoid if possible
-    def to_a
-      @target ||= list_of_proxies.map(&:target)
-    end
-
-    def target= (collection)
-      link_target(build_proxies(collection))
-    end
-
-    def target_ids=(object_ids)
-      link_target(build_proxies_with_ids(object_ids))
-    end
-
-    # Set the links on the nodes in the list
-    def link_target(new_proxies)
-      new_proxies.each_with_index do |proxy, idx|
-        proxy.next_id = new_proxies[idx+1].id unless new_proxies.length - 1 <= idx
-        proxy.prev_id = new_proxies[idx-1].id unless idx == 0
-      end
-
-      parent.head = new_proxies.first
-      parent.tail = new_proxies.last
-      parent.proxies = new_proxies
-    end
-
-    # TODO clear out the old proxies (or reuse them)
-    def build_proxies(objects)
-      # need to create the proxies before we can add the links otherwise the linked to resource won't exist
-      objects.map do |object|
-        Proxy.create(id: mint_proxy_id, target: object)
-      end
-    end
-
-    # TODO clear out the old proxies (or reuse them)
-    def build_proxies_with_ids(object_ids)
-      # need to create the proxies before we can add the links otherwise the linked to resource won't exist
-      object_ids.map do |file_id|
-        Proxy.create(id: mint_proxy_id, target_id: file_id)
-      end
-    end
-
-    def target_ids
-      list_of_proxies.map(&:target_id)
-    end
-
-    # @param obj [ActiveFedora::Base]
-    def << (obj)
-      node = if persisted?
-               parent.proxies.create(id: mint_proxy_id, target: obj, prev: parent.tail)
-             else
-               parent.proxies.build(id: mint_proxy_id, target: obj, prev: parent.tail)
-             end
-      # set the old tail, if present, to have this new proxy as its next
-      parent.tail.update(next: node) if parent.tail
-      # update the tail to point at the new node
-      parent.tail = node
-      # if this is the first node, set it to be the head
-      parent.head = node unless parent.head
-      reset_target!
-    end
-
-    def mint_proxy_id
-      "#{id}/#{SecureRandom.uuid}"
-    end
-
-    def self.find_or_initialize(id)
-      find(id)
-    rescue ActiveFedora::ObjectNotFoundError
-      new(id)
-    end
-
-    def reset_target!
-      @proxy_list = nil
-      @target = nil
-    end
-
-    # return the proxies in order
-    def list_of_proxies
-      @proxy_list ||= if parent.head
-        parent.head.as_list
-      else
-        []
-      end
-    end
-  end
-end

data/lib/active_fedora/aggregation/through_association.rb

@@ -1,25 +0,0 @@
-module ActiveFedora::Aggregation
-  class ThroughAssociation
-    def initialize(owner, reflection)
-      @owner, @reflection = owner, reflection
-    end
-
-    # has_one :aggregation
-    # has_many :generic_files, through: :aggregation
-    def reader
-      @file_association ||= Association.new(@owner, @reflection)
-    end
-
-    def writer(vals)
-      reader.target = vals
-    end
-
-    def ids_writer(vals)
-      reader.target_ids = vals
-    end
-
-    def ids_reader
-      reader.target_ids
-    end
-  end
-end