activefedora-aggregation 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1bb8da4f1630029337549d9975113e80a7882d7a
-  data.tar.gz: da0dc596fba4be563217e0eba4b066c9230bfdae
+  metadata.gz: f69090697f543089afbc0a5a0e83fd2deddb0b3a
+  data.tar.gz: 0d8775ae201b1ae026fca4d2ee0018079b0eb59d
 SHA512:
-  metadata.gz: a1760935368d3699da0320d8e768f653ca31434f59df34d7e5a6377d0994b38adfc02d101839e31219f21fc83263164a705b63acc24efc8a9d6e4286e999f280
-  data.tar.gz: 8a6e54cb29ba1821be04b8d4c9f63684a8133bcce86fd3182a81b0c3e89691e40e16888a85b934b257f38f12d74e65b50d75d717708271b8f86280a473c4b21b
+  metadata.gz: be36c19a9bd67b2c73ebf9398ae1a0b9dc324db7ca664b957c41d4496e743a21e55ea747f4a06f59ea2c0bdc6458dd1e732380252b589741837a9433b736a567
+  data.tar.gz: 80e91cdac629e9b372f5c8938cd50580d52c80a8c5b40e917ef1f88633f148d633837877fc50fc4bf951a337239a161ae6a22d92a6bf768d6c56e2a3cf7122aa

data/activefedora-aggregation.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency 'activesupport'
-  spec.add_dependency 'active-fedora', '~> 9.9.0'
+  spec.add_dependency 'active-fedora', '~> 9.10.1'
   spec.add_dependency 'rdf-vocab', '~> 0.8.1'
   # Avoid RDF 1.1.17 because of a bug from ruby 2.2
   # https://github.com/ruby-rdf/rdf/pull/213

data/lib/active_fedora/aggregation.rb

@@ -9,23 +9,9 @@ module ActiveFedora
   module Aggregation
     extend ActiveSupport::Autoload
     eager_autoload do
-      autoload :Association
-      autoload :AggregationExtension
       autoload :Proxy
-      autoload :Builder
-      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
       autoload :ListSource
     end
 

data/lib/active_fedora/aggregation/base_extension.rb

@@ -2,20 +2,6 @@ module ActiveFedora::Aggregation
   module BaseExtension
     extend ActiveSupport::Concern
 
-    # 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.
-      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
@@ -31,21 +17,7 @@ module ActiveFedora::Aggregation
         end
       end
 
-      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
-
       ##
       # Allows ordering of an association
       # @example
@@ -79,25 +51,6 @@ module ActiveFedora::Aggregation
         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
-        when :orders
-          ActiveFedora::Orders::Reflection.new(macro, name, options, active_fedora).tap do |reflection|
-            add_reflection name, reflection
-          end
-        else
-          super
-        end
-      end
     end
   end
 end

data/lib/active_fedora/aggregation/version.rb

@@ -1,5 +1,5 @@
 module ActiveFedora
   module Aggregation
-    VERSION = "0.9.0"
+    VERSION = "0.10.0"
   end
 end

data/lib/active_fedora/filter/builder.rb

@@ -1,7 +1,12 @@
 module ActiveFedora::Filter
   class Builder < ActiveFedora::Associations::Builder::CollectionAssociation
-    self.macro = :filter
-    self.valid_options = [:extending_from, :condition]
+    def self.valid_options(options)
+      super + [:extending_from, :condition]
+    end
+
+    def self.macro
+      :filter
+    end
 
     def self.define_readers(mixin, name)
       super
@@ -9,6 +14,20 @@ module ActiveFedora::Filter
         association(name).ids_reader
       end
     end
+
+    def self.create_reflection(model, name, scope, options, extension = nil)
+      unless name.is_a?(Symbol)
+        name = name.to_sym
+        Deprecation.warn(ActiveFedora::Base, "association names must be a Symbol")
+      end
+      validate_options(options)
+      translate_property_to_predicate(options)
+
+      scope = build_scope(scope, extension)
+      name = better_name(name)
+
+      ActiveFedora::Orders::Reflection.create(macro, name, scope, options, model)
+    end
   end
 end
 

data/lib/active_fedora/filter/reflection.rb

@@ -10,7 +10,7 @@ module ActiveFedora::Filter
     end
 
     def extending_from
-      @extending_from ||= active_fedora.reflect_on_association(options.fetch(:extending_from))
+      @extending_from ||= active_fedora._reflect_on_association(options.fetch(:extending_from))
     end
 
     def collection?

data/lib/active_fedora/orders/aggregation_builder.rb

@@ -1,47 +1,45 @@
 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
+    def self.valid_options(options)
+      [:through, :class_name, :has_member_relation, :type_validator]
     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
+    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
 
     private
 
-    def indirect_options
+    def self.indirect_options(options)
       {
         class_name: options[:class_name],
         type_validator: options[:type_validator]
-      }.select{ |k, v| v.present? }
+      }.select { |k, v| v.present? }
     end
 
-    def has_member_relation
+    def self.has_member_relation(options)
       options[:has_member_relation] || ::RDF::DC.hasPart
     end
 
-    def inserted_content_relation
+    def self.inserted_content_relation
       ::RDF::Vocab::ORE::proxyFor
     end
 
-    def proxy_class
+    def self.proxy_class
       "ActiveFedora::Aggregation::Proxy"
     end
 
-    def proxy_foreign_key
+    def self.proxy_foreign_key
       :target
     end
 
-    def contains_key
+    def self.contains_key(options)
       options[:through]
     end
 
-    def list_source_class
+    def self.list_source_class
       "ActiveFedora::Aggregation::ListSource"
     end
   end

data/lib/active_fedora/orders/association.rb

@@ -12,6 +12,7 @@ module ActiveFedora::Orders
 
     def reader(*args)
       @proxy ||= ActiveFedora::Orders::CollectionProxy.new(self)
+      @null_proxy ||= ActiveFedora::Orders::CollectionProxy.new(self)
       super
     end
 
@@ -144,11 +145,11 @@ module ActiveFedora::Orders
     end
 
     def unordered_association
-      owner.association(ordered_reflection_name)
+      owner.association(unordered_reflection_name)
     end
 
-    def ordered_reflection_name
-      reflection.ordered_reflection.name
+    def unordered_reflection_name
+      reflection.unordered_reflection.name
     end
   end
 end

data/lib/active_fedora/orders/builder.rb

@@ -1,8 +1,13 @@
 module ActiveFedora::Orders
   class Builder < ActiveFedora::Associations::Builder::CollectionAssociation
     include ActiveFedora::AutosaveAssociation::AssociationBuilderExtension
-    self.macro = :orders
-    self.valid_options += [:through, :ordered_reflection]
+    def self.macro
+      :orders
+    end
+
+    def self.valid_options(options)
+      super + [:through, :unordered_reflection]
+    end
 
     def self.define_readers(mixin, name)
       super
@@ -14,14 +19,37 @@ module ActiveFedora::Orders
       end
     end
 
-    def initialize(model, name, options)
-      @original_name = name
-      @model = model
+    def self.build(model, name, options)
+      options = { unordered_reflection: unordered_reflection(model, name)}.merge(options)
       name = :"ordered_#{name.to_s.singularize}_proxies"
-      options = {ordered_reflection: ordered_reflection}.merge(options)
+      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::Orders::Builder::FixFirstLast
       super
     end
 
+    def self.create_reflection(model, name, scope, options, extension = nil)
+      unless name.is_a?(Symbol)
+        name = name.to_sym
+        Deprecation.warn(ActiveFedora::Base, "association names must be a Symbol")
+      end
+      validate_options(options)
+      translate_property_to_predicate(options)
+
+      scope = build_scope(scope, extension)
+      name = better_name(name)
+
+      ActiveFedora::Orders::Reflection.create(macro, name, scope, options, model)
+    end
+
     module FixFirstLast
       def save(*args)
         super.tap do |result|
@@ -39,29 +67,14 @@ module ActiveFedora::Orders
       end
     end
 
-    def build
-      super.tap do |result|
-        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(result.options[:through])
-          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::Orders::Builder::FixFirstLast
-      end
-    end
-
     private
 
     def self.target_accessor(name)
       name.to_s.gsub("_proxies","").pluralize
     end
 
-    def ordered_reflection
-      model.reflect_on_association(@original_name)
+    def self.unordered_reflection(model, original_name)
+      model._reflect_on_association(original_name)
     end
   end
 end

data/lib/active_fedora/orders/reflection.rb

@@ -1,5 +1,20 @@
 module ActiveFedora::Orders
   class Reflection < ActiveFedora::Reflection::AssociationReflection
+    class << self
+      def create(macro, name, scope, options, active_fedora)
+        klass = case macro
+                  when :aggregation
+                    Reflection
+                  when :filter
+                    ActiveFedora::Filter::Reflection
+                  when :orders
+                    ActiveFedora::Orders::Reflection
+                  end
+        reflection = klass.new(macro, name, scope, options, active_fedora)
+        ActiveFedora::Reflection.add_reflection(active_fedora, name, reflection)
+        reflection
+      end
+    end
     def association_class
       Association
     end
@@ -12,8 +27,8 @@ module ActiveFedora::Orders
       klass.to_s
     end
 
-    def ordered_reflection
-      options[:ordered_reflection]
+    def unordered_reflection
+      options[:unordered_reflection]
     end
 
     def klass

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activefedora-aggregation
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Justin Coyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-24 00:00:00.000000000 Z
+date: 2016-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 9.9.0
+        version: 9.10.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 9.9.0
+        version: 9.10.1
 - !ruby/object:Gem::Dependency
   name: rdf-vocab
   requirement: !ruby/object:Gem::Requirement
@@ -177,24 +177,10 @@ files:
 - 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/list_source.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_owner.rb
-- lib/active_fedora/aggregation/proxy_repository.rb
-- lib/active_fedora/aggregation/reflection.rb
 - lib/active_fedora/aggregation/version.rb
 - lib/active_fedora/filter.rb
 - lib/active_fedora/filter/association.rb
@@ -246,9 +232,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Aggregations for active-fedora
 test_files: []
-has_rdoc: 

data/lib/active_fedora/aggregation/aggregation_extension.rb

@@ -1,26 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-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,81 +0,0 @@
-module ActiveFedora::Aggregation
-  class Association < ::ActiveFedora::Associations::IndirectlyContainsAssociation
-    delegate :first, to: :ordered_reader
-
-    def ordered_reader
-      OrderedReader.new(owner).to_a.map(&:target)
-    end
-
-    def proxy_class
-      @proxy_class ||= ProxyRepository.new(owner, super)
-    end
-
-    def options
-      @all_options ||= default_options.merge(super)
-    end
-
-    # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
-    def ids_reader
-      return [] if @owner.new_record?
-      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
-    end
-
-    private
-
-    # Write a query to find the proxies
-    def construct_proxy_query
-      raise "Owner must have an identifier" unless @owner.id
-      @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
-
-    # 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
-
-    # @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)
-      proxy_for = first.fetch('proxyFor_ssim', []).first
-      if proxy_for
-        create_linked_list(next_id, remainder, list + [proxy_for])
-      else
-        ActiveFedora::Base.logger.error("Found a proxy (id: #{first['id']}) that has no proxyFor_ssim") if ActiveFedora::Base.logger
-        create_linked_list(next_id, remainder, list)
-      end
-    end
-
-    def default_options
-      { through: default_proxy_class, foreign_key: :target, has_member_relation: reflection.predicate, inserted_content_relation: content_relation }
-    end
-
-    def content_relation
-      default_proxy_class.constantize.reflect_on_association(:target).predicate
-    end
-
-    def default_proxy_class
-      'ActiveFedora::Aggregation::Proxy'
-    end
-
-  end
-end

data/lib/active_fedora/aggregation/builder.rb

@@ -1,33 +0,0 @@
-module ActiveFedora::Aggregation
-  class Builder < ActiveFedora::Associations::Builder::CollectionAssociation
-    include ActiveFedora::AutosaveAssociation::AssociationBuilderExtension
-    self.macro = :aggregation
-
-    def build
-      reflection = super
-      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
-
-    def self.define_readers(mixin, name)
-      super
-      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)
-      super
-      mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
-        association(name).ids_writer(ids)
-      end
-    end
-
-  end
-end

data/lib/active_fedora/aggregation/decorating_repository.rb

@@ -1,29 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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/persist_links.rb

@@ -1,9 +0,0 @@
-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_owner.rb

@@ -1,24 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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,28 +0,0 @@
-module ActiveFedora::Aggregation
-  class Reflection < ActiveFedora::Reflection::AssociationReflection
-    def association_class
-      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?
-      true
-    end
-  end
-end