active-fedora 9.10.0.pre1 → 9.10.0.pre2

data/lib/active_fedora/file_persistence.rb

@@ -0,0 +1,27 @@
+module ActiveFedora
+  module FilePersistence
+    extend ActiveSupport::Concern
+
+    include ActiveFedora::Persistence
+
+    private
+
+      def _create_record(_options = {})
+        return false if content.nil?
+        ldp_source.content = content
+        ldp_source.create do |req|
+          req.headers.merge!(ldp_headers)
+        end
+        refresh
+      end
+
+      def _update_record(_options = {})
+        return true unless content_changed?
+        ldp_source.content = content
+        ldp_source.update do |req|
+          req.headers.merge!(ldp_headers)
+        end
+        refresh
+      end
+  end
+end

data/lib/active_fedora/identifiable.rb

@@ -78,11 +78,6 @@ module ActiveFedora
       rescue ActiveFedora::ObjectNotFoundError, Ldp::Gone
         ActiveTriples::Resource.new(uri)
       end
-
-      # Abstract classes can't have default scopes.
-      def abstract_class?
-        self == Base
-      end
     end
   end
 end

data/lib/active_fedora/indexing.rb

@@ -59,14 +59,14 @@ module ActiveFedora
     private
 
       # index the record after it has been persisted to Fedora
-      def create_record(options = {})
+      def _create_record(options = {})
         super
         update_index if create_needs_index? && options.fetch(:update_index, true)
         true
       end
 
       # index the record after it has been updated in Fedora
-      def update_record(options = {})
+      def _update_record(options = {})
         super
         update_index if update_needs_index? && options.fetch(:update_index, true)
         true

data/lib/active_fedora/inheritance.rb

@@ -0,0 +1,34 @@
+module ActiveFedora
+  module Inheritance
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Returns the class descending directly from ActiveFedora::Base, or
+      # an abstract class, if any, in the inheritance hierarchy.
+      #
+      # If A extends ActiveFedora::Base, A.base_class will return A. If B descends from A
+      # through some arbitrarily deep hierarchy, B.base_class will return A.
+      #
+      # If B < A and C < B and if A is an abstract_class then both B.base_class
+      # and C.base_class would return B as the answer since A is an abstract_class.
+      def base_class
+        return File if self == File || superclass == File
+
+        unless self <= Base
+          raise ActiveFedoraError, "#{name} doesn't belong in a hierarchy descending from ActiveFedora"
+        end
+
+        if self == Base || superclass == Base || superclass.abstract_class?
+          self
+        else
+          superclass.base_class
+        end
+      end
+
+      # Abstract classes can't have default scopes.
+      def abstract_class?
+        self == Base
+      end
+    end
+  end
+end

data/lib/active_fedora/persistence.rb

@@ -33,7 +33,7 @@ module ActiveFedora
 
     # Pushes the object and all of its new or dirty attached files into Fedora
     def update(attributes)
-      self.attributes = attributes
+      assign_attributes(attributes)
       save
     end
 
@@ -70,6 +70,17 @@ module ActiveFedora
       delete(*opts)
     end
 
+    # Deletes the record in the database and freezes this instance to reflect
+    # that no changes should be made (since they can't be persisted).
+    #
+    # There's a series of callbacks associated with #destroy!. If the
+    # <tt>before_destroy</tt> callback throws +:abort+ the action is cancelled
+    # and #destroy! raises ActiveFedora::RecordNotDestroyed.
+    # See ActiveFedora::Callbacks for further details.
+    def destroy!
+      destroy || _raise_record_not_destroyed
+    end
+
     def eradicate
       self.class.eradicate(id)
     end
@@ -138,12 +149,12 @@ module ActiveFedora
 
       def create_or_update(*args)
         raise ReadOnlyRecord if readonly?
-        result = new_record? ? create_record(*args) : update_record(*args)
+        result = new_record? ? _create_record(*args) : _update_record(*args)
         result != false
       end
 
       # Deals with preparing new object to be saved to Fedora, then pushes it and its attached files into Fedora.
-      def create_record(_options = {})
+      def _create_record(_options = {})
         assign_rdf_subject
         serialize_attached_files
         @ldp_source = @ldp_source.create
@@ -152,13 +163,20 @@ module ActiveFedora
         refresh
       end
 
-      def update_record(_options = {})
+      def _update_record(_options = {})
         serialize_attached_files
         execute_sparql_update
         save_contained_resources
         refresh
       end
 
+      def _raise_record_not_destroyed
+        @_association_destroy_exception ||= nil
+        raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy the record", self)
+      ensure
+        @_association_destroy_exception = nil
+      end
+
       def refresh
         @ldp_source = build_ldp_resource(id)
         @resource = nil

data/lib/active_fedora/scoping.rb

@@ -1,6 +1,9 @@
+require 'active_support/per_thread_registry'
+
 module ActiveFedora
   module Scoping
     extend ActiveSupport::Concern
+
     included do
       include Default
       include Named
@@ -8,11 +11,17 @@ module ActiveFedora
 
     module ClassMethods
       def current_scope #:nodoc:
-        Thread.current["#{self}_current_scope"]
+        ScopeRegistry.value_for(:current_scope, self)
       end
 
       def current_scope=(scope) #:nodoc:
-        Thread.current["#{self}_current_scope"] = scope
+        ScopeRegistry.set_value_for(:current_scope, self, scope)
+      end
+
+      # Collects attributes from scopes that should be applied when creating
+      # an AF instance for the particular class this is called on.
+      def scope_attributes # :nodoc:
+        all.scope_for_create
       end
 
       # Are there attributes associated with this scope?
@@ -20,5 +29,74 @@ module ActiveFedora
         current_scope
       end
     end
+
+    def populate_with_current_scope_attributes # :nodoc:
+      return unless self.class.scope_attributes?
+
+      self.class.scope_attributes.each do |att, value|
+        send("#{att}=", value) if respond_to?("#{att}=")
+      end
+    end
+
+    def initialize_internals_callback # :nodoc:
+      super
+      populate_with_current_scope_attributes
+    end
+
+    # This class stores the +:current_scope+ and +:ignore_default_scope+ values
+    # for different classes. The registry is stored as a thread local, which is
+    # accessed through +ScopeRegistry.current+.
+    #
+    # This class allows you to store and get the scope values on different
+    # classes and different types of scopes. For example, if you are attempting
+    # to get the current_scope for the +Board+ model, then you would use the
+    # following code:
+    #
+    #   registry = ActiveFedora::Scoping::ScopeRegistry
+    #   registry.set_value_for(:current_scope, Board, some_new_scope)
+    #
+    # Now when you run:
+    #
+    #   registry.value_for(:current_scope, Board)
+    #
+    # You will obtain whatever was defined in +some_new_scope+. The #value_for
+    # and #set_value_for methods are delegated to the current ScopeRegistry
+    # object, so the above example code can also be called as:
+    #
+    #   ActiveFedora::Scoping::ScopeRegistry.set_value_for(:current_scope,
+    #       Board, some_new_scope)
+    class ScopeRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope].freeze
+
+      def initialize
+        @registry = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      # Obtains the value for a given +scope_type+ and +model+.
+      def value_for(scope_type, model)
+        raise_invalid_scope_type!(scope_type)
+        klass = model
+        base = model.base_class
+        while klass <= base
+          value = @registry[scope_type][klass.name]
+          return value if value
+          klass = klass.superclass
+        end
+      end
+
+      # Sets the +value+ for a given +scope_type+ and +model+.
+      def set_value_for(scope_type, model, value)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][model.name] = value
+      end
+
+      private
+
+        def raise_invalid_scope_type!(scope_type)
+          raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES" unless VALID_SCOPE_TYPES.include?(scope_type)
+        end
+    end
   end
 end

data/lib/active_fedora/scoping/default.rb

@@ -46,6 +46,10 @@ module ActiveFedora
           super || default_scopes.any? || respond_to?(:default_scope)
         end
 
+        def before_remove_const #:nodoc:
+          self.current_scope = nil
+        end
+
         protected
 
           # Use this macro in your model to set a default scope for all operations on
@@ -125,11 +129,11 @@ module ActiveFedora
           end
 
           def ignore_default_scope? # :nodoc:
-            Thread.current["#{self}_ignore_default_scope"]
+            ScopeRegistry.value_for(:ignore_default_scope, base_class)
           end
 
           def ignore_default_scope=(ignore) # :nodoc:
-            Thread.current["#{self}_ignore_default_scope"] = ignore
+            ScopeRegistry.set_value_for(:ignore_default_scope, base_class, ignore)
           end
 
           # The ignore_default_scope flag is used to prevent an infinite recursion

data/lib/active_fedora/scoping/named.rb

@@ -16,7 +16,7 @@ module ActiveFedora
         #   fruits = fruits.limit(10) if limited?
         #
         # You can define a scope that applies to all finders using
-        # <tt>ActiveRecord::Base.default_scope</tt>.
+        # <tt>ActiveFedora::Base.default_scope</tt>.
         def all
           if current_scope
             current_scope.clone
@@ -34,6 +34,146 @@ module ActiveFedora
             relation
           end
         end
+
+        # Adds a class method for retrieving and querying objects.
+        # The method is intended to return an ActiveFedora::Relation
+        # object, which is composable with other scopes.
+        # If it returns nil or false, an
+        # {all}[rdoc-ref:Scoping::Named::ClassMethods#all] scope is returned instead.
+        #
+        # A \scope represents a narrowing of a database query, such as
+        # <tt>where(color: :red).select('shirts.*').includes(:washing_instructions)</tt>.
+        #
+        #   class Shirt < ActiveFedora::Base
+        #     scope :red, -> { where(color: 'red') }
+        #     scope :dry_clean_only, -> { joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true) }
+        #   end
+        #
+        # The above calls to #scope define class methods <tt>Shirt.red</tt> and
+        # <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, in effect,
+        # represents the query <tt>Shirt.where(color: 'red')</tt>.
+        #
+        # You should always pass a callable object to the scopes defined
+        # with #scope. This ensures that the scope is re-evaluated each
+        # time it is called.
+        #
+        # Note that this is simply 'syntactic sugar' for defining an actual
+        # class method:
+        #
+        #   class Shirt < ActiveFedora::Base
+        #     def self.red
+        #       where(color: 'red')
+        #     end
+        #   end
+        #
+        # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by
+        # <tt>Shirt.red</tt> is not an Array but an ActiveFedora::Relation,
+        # which is composable with other scopes; it resembles the association object
+        # constructed by a {has_many}[rdoc-ref:Associations::ClassMethods#has_many]
+        # declaration. For instance, you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>,
+        # <tt>Shirt.red.where(size: 'small')</tt>. Also, just as with the
+        # association objects, named \scopes act like an Array, implementing
+        # Enumerable; <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>,
+        # and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if
+        # <tt>Shirt.red</tt> really was an array.
+        #
+        # These named \scopes are composable. For instance,
+        # <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are
+        # both red and dry clean only. Nested finds and calculations also work
+        # with these compositions: <tt>Shirt.red.dry_clean_only.count</tt>
+        # returns the number of garments for which these criteria obtain.
+        # Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
+        #
+        # All scopes are available as class methods on the ActiveFedora::Base
+        # descendant upon which the \scopes were defined. But they are also
+        # available to {has_many}[rdoc-ref:Associations::ClassMethods#has_many]
+        # associations. If,
+        #
+        #   class Person < ActiveFedora::Base
+        #     has_many :shirts
+        #   end
+        #
+        # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of
+        # Elton's red, dry clean only shirts.
+        #
+        # \Named scopes can also have extensions, just as with
+        # {has_many}[rdoc-ref:Associations::ClassMethods#has_many] declarations:
+        #
+        #   class Shirt < ActiveFedora::Base
+        #     scope :red, -> { where(color: 'red') } do
+        #       def dom_id
+        #         'red_shirts'
+        #       end
+        #     end
+        #   end
+        #
+        # Scopes can also be used while creating/building a record.
+        #
+        #   class Article < ActiveFedora::Base
+        #     scope :published, -> { where(published: true) }
+        #   end
+        #
+        #   Article.published.new.published    # => true
+        #   Article.published.create.published # => true
+        #
+        # \Class methods on your model are automatically available
+        # on scopes. Assuming the following setup:
+        #
+        #   class Article < ActiveFedora::Base
+        #     scope :published, -> { where(published: true) }
+        #     scope :featured, -> { where(featured: true) }
+        #
+        #     def self.latest_article
+        #       order('published_at desc').first
+        #     end
+        #
+        #     def self.titles
+        #       pluck(:title)
+        #     end
+        #   end
+        #
+        # We are able to call the methods like this:
+        #
+        #   Article.published.featured.latest_article
+        #   Article.featured.titles
+        def scope(name, body, &block)
+          unless body.respond_to?(:call)
+            raise ArgumentError, 'The scope body needs to be callable.'
+          end
+
+          if dangerous_class_method?(name)
+            raise ArgumentError, "You tried to define a scope named \"#{name}\" " \
+              "on the model \"#{self.name}\", but Active Record already defined " \
+              "a class method with the same name."
+          end
+
+          valid_scope_name?(name)
+          extension = Module.new(&block) if block
+
+          if body.respond_to?(:to_proc)
+            singleton_class.send(:define_method, name) do |*args|
+              scope = all.scoping { instance_exec(*args, &body) }
+              scope = scope.extending(extension) if extension
+
+              scope || all
+            end
+          else
+            singleton_class.send(:define_method, name) do |*args|
+              scope = all.scoping { body.call(*args) }
+              scope = scope.extending(extension) if extension
+
+              scope || all
+            end
+          end
+        end
+
+        protected
+
+          def valid_scope_name?(name)
+            return unless respond_to?(name, true)
+            logger.warn "Creating scope :#{name}. " \
+                        "Overwriting existing method #{self.name}.#{name}."
+          end
       end
     end
   end

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "9.10.0.pre1".freeze
+  VERSION = "9.10.0.pre2".freeze
 end

data/spec/integration/collection_association_spec.rb

@@ -11,8 +11,6 @@ describe ActiveFedora::Base do
   end
 
   let(:library) { Library.create! }
-  let!(:book1) { Book.create!(library: library) }
-  let!(:book2) { Book.create!(library: library) }
 
   after do
     Object.send(:remove_const, :Library)
@@ -20,6 +18,9 @@ describe ActiveFedora::Base do
   end
 
   describe "load_from_solr" do
+    let!(:book1) { Book.create!(library: library) }
+    let!(:book2) { Book.create!(library: library) }
+
     it "sets rows to count, if not specified" do
       expect(library.books(response_format: :solr).size).to eq 2
     end
@@ -35,6 +36,8 @@ describe ActiveFedora::Base do
   end
 
   describe "#delete_all" do
+    let!(:book1) { Book.create!(library: library) }
+    let!(:book2) { Book.create!(library: library) }
     it "deletes em" do
       expect {
         library.books.delete_all
@@ -59,6 +62,8 @@ describe ActiveFedora::Base do
   end
 
   describe "#destroy_all" do
+    let!(:book1) { Book.create!(library: library) }
+    let!(:book2) { Book.create!(library: library) }
     it "deletes em" do
       expect {
         library.books.destroy_all
@@ -67,6 +72,8 @@ describe ActiveFedora::Base do
   end
 
   describe "#find" do
+    let!(:book1) { Book.create!(library: library) }
+    let!(:book2) { Book.create!(library: library) }
     it "finds the record that matches" do
       expected = library.books.find(book1.id)
       expect(expected).to eq book1
@@ -80,8 +87,11 @@ describe ActiveFedora::Base do
   end
 
   describe "#select" do
+    let!(:book1) { Book.create!(library: library) }
+    let!(:book2) { Book.create!(library: library) }
+
     # TODO: Bug described in issue #609
-    xit "should choose a subset of objects in the relationship" do
+    xit "chooses a subset of objects in the relationship" do
       expect(library.books.select([:id])).to include(book1.id)
     end
     it "works as a block" do
@@ -89,6 +99,27 @@ describe ActiveFedora::Base do
     end
   end
 
+  describe "#size" do
+    context "with associations in memory" do
+      context "and the association is already loaded" do
+        before do
+          library.books.to_a # force the association to be loaded
+          library.books.build
+        end
+        subject { library.books.size }
+        it { is_expected.to eq 1 }
+      end
+
+      context "and the association is not loaded" do
+        before do
+          library.books.build
+        end
+        subject { library.books.size }
+        it { is_expected.to eq 1 }
+      end
+    end
+  end
+
   describe "finding the inverse" do
     context "when no inverse exists" do
       before do