active-fedora 9.10.0.pre1 → 9.10.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7df084ee06f2755c8ff2fc057f8b6a8751bd142a
-  data.tar.gz: 622c46cd850334fe1950625b1e9a5b869f0dd2c0
+  metadata.gz: b9fa729bb22950bf6f1a5a8910eef83e17d699b6
+  data.tar.gz: 2230ceaf9cf100c0737997c5235c0a87364ec2df
 SHA512:
-  metadata.gz: df6c6b7f8af5f3e511434c06b0e667a3234841c4483dac0a7f508cddf89d4e056a087d7ea2186ea0b454133ff8b027e692bd8acf190bd93a4969c7effd874d09
-  data.tar.gz: 17116f1df54b097ad14272537509d976f3eb9dd9f8911dca31c6ea80ce478af5c398255066628b5620938b5ee3a393a15af58577ac2d7ed3c88bf19e91df47ea
+  metadata.gz: df06b4f7448346189c3ca49029200205eaf671a84854035fba131dc60d84f0954aaf79df54e29746118cac1074ca2241e7b5bc7e291f89b120e44340b034d250
+  data.tar.gz: 60a819b84ffd5f68bdb80436648621738e2b77b68e629265be3d3257efa566969d33c040660a561445c39a60d38742865afd0dd6b6681ef0aeb7bfc8cd08d961

data/.rubocop.yml

@@ -43,6 +43,9 @@ Metrics/CyclomaticComplexity:
     - 'lib/active_fedora/file_configurator.rb'
     - 'lib/active_fedora/file.rb'
     - 'lib/active_fedora/datastreams/nokogiri_datastreams.rb'
+    - 'lib/active_fedora/attribute_methods.rb'
+    - 'lib/active_fedora/scoping/named.rb'
+    - 'lib/active_fedora/inheritance.rb'
 
 Metrics/PerceivedComplexity:
   Exclude:
@@ -57,6 +60,9 @@ Metrics/PerceivedComplexity:
     - 'lib/active_fedora/associations/builder/indirectly_contains.rb'
     - 'lib/active_fedora/associations/builder/directly_contains_one.rb'
     - 'lib/active_fedora/associations/collection_association.rb'
+    - 'lib/active_fedora/attribute_methods.rb'
+    - 'lib/active_fedora/scoping/named.rb'
+    - 'lib/active_fedora/inheritance.rb'
 
 Metrics/ModuleLength:
   Exclude:
@@ -103,6 +109,7 @@ Style/AccessorMethodName:
 
 Style/PredicateName:
   Exclude:
+    - 'lib/active_fedora/attribute_methods.rb'
     - 'lib/active_fedora/relation/finder_methods.rb'
     - 'lib/active_fedora/versionable.rb'
     - 'lib/active_fedora/reflection.rb'

data/lib/active_fedora.rb

@@ -40,6 +40,7 @@ module ActiveFedora #:nodoc:
     autoload :AssociationRelation
     autoload :Associations
     autoload :AttachedFiles
+    autoload :AttributeAssignment
     autoload :AttributeMethods
     autoload :Attributes
     autoload :AutosaveAssociation
@@ -50,6 +51,7 @@ module ActiveFedora #:nodoc:
     autoload :Checksum
     autoload :CleanConnection
     autoload :Config
+    autoload :Common
     autoload :Core
     autoload_under 'containers' do
       autoload :Container
@@ -71,6 +73,7 @@ module ActiveFedora #:nodoc:
     autoload :File
     autoload :FileConfigurator
     autoload :FilePathBuilder
+    autoload :FilePersistence
     autoload :FileRelation
     autoload :FilesHash
     autoload :FixityService
@@ -79,6 +82,7 @@ module ActiveFedora #:nodoc:
     autoload :Indexing
     autoload :IndexingService
     autoload :InheritableAccessors
+    autoload :Inheritance
     autoload :InboundRelationConnection
     autoload :LdpCache
     autoload :LdpResource

data/lib/active_fedora/associations/collection_association.rb

@@ -72,10 +72,10 @@ module ActiveFedora
       # This method is abstract in the sense that it relies on
       # +count_records+, which is a method descendants have to provide.
       def size
-        if @owner.new_record? && @target
-          @target.size
-        elsif !loaded? && @target.is_a?(Array)
-          unsaved_records = @target.select(&:new_record?)
+        if !find_target? || loaded?
+          target.size
+        elsif !loaded? && target.is_a?(Array)
+          unsaved_records = target.select(&:new_record?)
           unsaved_records.size + count_records
         else
           count_records
@@ -212,7 +212,7 @@ module ActiveFedora
         if attrs.is_a?(Array)
           attrs.collect { |attr| create(attr) }
         else
-          create_record(attrs) do |record|
+          _create_record(attrs) do |record|
             yield(record) if block_given?
             record.save
           end
@@ -220,7 +220,7 @@ module ActiveFedora
       end
 
       def create!(attrs = {})
-        create_record(attrs) do |record|
+        _create_record(attrs) do |record|
           yield(record) if block_given?
           record.save!
         end
@@ -340,7 +340,7 @@ module ActiveFedora
           end
         end
 
-        def create_record(attributes, raise = false)
+        def _create_record(attributes, raise = false)
           attributes.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
           ensure_owner_is_not_new
 

data/lib/active_fedora/attribute_assignment.rb

@@ -0,0 +1,55 @@
+require 'active_support/core_ext/hash/keys'
+
+module ActiveFedora
+  module AttributeAssignment
+    include ActiveModel::ForbiddenAttributesProtection
+
+    # Alias for assign_attributes.
+    def attributes=(attributes)
+      assign_attributes(attributes)
+    end
+
+    # Allows you to set all the attributes by passing in a hash of attributes with
+    # keys matching the attribute names.
+    #
+    # If the passed hash responds to <tt>permitted?</tt> method and the return value
+    # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
+    # exception is raised.
+    #
+    #   class Cat
+    #     include ActiveModel::AttributeAssignment
+    #     attr_accessor :name, :status
+    #   end
+    #
+    #   cat = Cat.new
+    #   cat.assign_attributes(name: "Gorby", status: "yawning")
+    #   cat.name # => 'Gorby'
+    #   cat.status => 'yawning'
+    #   cat.assign_attributes(status: "sleeping")
+    #   cat.name # => 'Gorby'
+    #   cat.status => 'sleeping'
+    def assign_attributes(new_attributes)
+      unless new_attributes.respond_to?(:stringify_keys)
+        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
+      end
+      return if new_attributes.nil? || new_attributes.empty?
+
+      attributes = new_attributes.stringify_keys
+      _assign_attributes(sanitize_for_mass_assignment(attributes))
+    end
+
+    private
+
+      def _assign_attributes(attributes)
+        attributes.each do |k, v|
+          _assign_attribute(k, v)
+        end
+      end
+
+      def _assign_attribute(k, v)
+        raise UnknownAttributeError.new(self, k) unless respond_to?("#{k}=")
+
+        public_send("#{k}=", v)
+      end
+  end
+end

data/lib/active_fedora/attribute_methods.rb

@@ -13,26 +13,97 @@ module ActiveFedora
       end
     end
 
-    class AttributeMethodCache
-      def initialize
-        @module = Module.new
-        @method_cache = ThreadSafe::Cache.new
+    BLACKLISTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass).freeze
+
+    class GeneratedAttributeMethods < Module; end # :nodoc:
+
+    module ClassMethods
+      def inherited(child_class) #:nodoc:
+        child_class.initialize_generated_modules
+        super
+      end
+
+      def initialize_generated_modules # :nodoc:
+        @generated_attribute_methods = GeneratedAttributeMethods.new { extend Mutex_m }
+        @attribute_methods_generated = false
+        include @generated_attribute_methods
+
+        super
+      end
+
+      # Raises an ActiveRecord::DangerousAttributeError exception when an
+      # \Active \Record method is defined in the model, otherwise +false+.
+      #
+      #   class Person < ActiveRecord::Base
+      #     def save
+      #       'already defined by Active Record'
+      #     end
+      #   end
+      #
+      #   Person.instance_method_already_implemented?(:save)
+      #   # => ActiveRecord::DangerousAttributeError: save is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name.
+      #
+      #   Person.instance_method_already_implemented?(:name)
+      #   # => false
+      def instance_method_already_implemented?(method_name)
+        if dangerous_attribute_method?(method_name)
+          raise DangerousAttributeError, "#{method_name} is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name."
+        end
+
+        if superclass == Base
+          super
+        else
+          # If ThisClass < ... < SomeSuperClass < ... < Base and SomeSuperClass
+          # defines its own attribute method, then we don't want to overwrite that.
+          defined = method_defined_within?(method_name, superclass, Base) &&
+                    !superclass.instance_method(method_name).owner.is_a?(GeneratedAttributeMethods)
+          defined || super
+        end
+      end
+
+      # A method name is 'dangerous' if it is already (re)defined by Active Fedora, but
+      # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
+      def dangerous_attribute_method?(name) # :nodoc:
+        method_defined_within?(name, Base)
+      end
+
+      def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
+        if klass.method_defined?(name) || klass.private_method_defined?(name)
+          if superklass.method_defined?(name) || superklass.private_method_defined?(name)
+            klass.instance_method(name).owner != superklass.instance_method(name).owner
+          else
+            true
+          end
+        else
+          false
+        end
+      end
+
+      # A class method is 'dangerous' if it is already (re)defined by Active Record, but
+      # not by any ancestors. (So 'puts' is not dangerous but 'new' is.)
+      def dangerous_class_method?(method_name)
+        BLACKLISTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Base)
       end
 
-      def [](name)
-        @method_cache.compute_if_absent(name) do
-          safe_name = name.unpack('h*').first
-          temp_method = "__temp__#{safe_name}"
-          ActiveFedora::AttributeMethods::AttrNames.set_name_cache safe_name, name
-          @module.module_eval method_body(temp_method, safe_name), __FILE__, __LINE__
-          @module.instance_method temp_method
+      def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
+        if klass.respond_to?(name, true)
+          if superklass.respond_to?(name, true)
+            klass.method(name).owner != superklass.method(name).owner
+          else
+            true
+          end
+        else
+          false
         end
       end
 
       private
 
-        def method_body
-          raise NotImplementedError
+        # @param name [Symbol] name of the attribute to generate
+        def generate_method(name)
+          generated_attribute_methods.synchronize do
+            define_attribute_methods name
+          end
         end
     end
 
@@ -43,6 +114,19 @@ module ActiveFedora
       include Dirty
     end
 
+    # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
+    #
+    #   class Person < ActiveRecord::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person.has_attribute?(:name)    # => true
+    #   person.has_attribute?('age')    # => true
+    #   person.has_attribute?(:nothing) # => false
+    def has_attribute?(attr_name)
+      attribute_names.include?(attr_name.to_s)
+    end
+
     # Returns an array of names for the attributes available on this object.
     #
     #   class Person < ActiveFedora::Base
@@ -69,6 +153,58 @@ module ActiveFedora
       end
     end
 
+    # Returns an <tt>#inspect</tt>-like string for the value of the
+    # attribute +attr_name+. String attributes are truncated up to 50
+    # characters, Date and Time attributes are returned in the
+    # <tt>:db</tt> format, Array attributes are truncated up to 10 values.
+    # Other attributes return the value of <tt>#inspect</tt> without
+    # modification.
+    #
+    #   person = Person.create!(name: 'David Heinemeier Hansson ' * 3)
+    #
+    #   person.attribute_for_inspect(:name)
+    #   # => "\"David Heinemeier Hansson David Heinemeier Hansson ...\""
+    #
+    #   person.attribute_for_inspect(:created_at)
+    #   # => "\"2012-10-22 00:15:07\""
+    #
+    #   person.attribute_for_inspect(:tag_ids)
+    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...]"
+    def attribute_for_inspect(attr_name)
+      value = self[attr_name]
+
+      if value.is_a?(String) && value.length > 50
+        "#{value[0, 50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value.to_s(:db)}")
+      elsif value.is_a?(Array) && value.size > 10
+        inspected = value.first(10).inspect
+        %(#{inspected[0...-1]}, ...])
+      else
+        value.inspect
+      end
+    end
+
+    # Returns +true+ if the specified +attribute+ has been set by the user or by a
+    # database load and is neither +nil+ nor <tt>empty?</tt> (the latter only applies
+    # to objects that respond to <tt>empty?</tt>, most notably Strings). Otherwise, +false+.
+    # Note that it always returns +true+ with boolean attributes.
+    #
+    #   class Task < ActiveRecord::Base
+    #   end
+    #
+    #   task = Task.new(title: '', is_done: false)
+    #   task.attribute_present?(:title)   # => false
+    #   task.attribute_present?(:is_done) # => true
+    #   task.title = 'Buy milk'
+    #   task.is_done = true
+    #   task.attribute_present?(:title)   # => true
+    #   task.attribute_present?(:is_done) # => true
+    def attribute_present?(attribute)
+      value = self[attribute]
+      !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
+    end
+
     # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
     # "2004-12-12" in a date column is cast to a date object, like Date.new(2004, 12, 12)). It raises
     # <tt>ActiveModel::MissingAttributeError</tt> if the identified attribute is missing.
@@ -103,39 +239,5 @@ module ActiveFedora
     def []=(attr_name, value)
       write_attribute(attr_name, value)
     end
-
-    module ClassMethods
-      def initialize_generated_modules # :nodoc:
-        @generated_attribute_methods = Module.new { extend Mutex_m }
-        include @generated_attribute_methods
-      end
-
-      # A method name is 'dangerous' if it is already (re)defined by Active Fedora, but
-      # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
-      def dangerous_attribute_method?(name) # :nodoc:
-        method_defined_within?(name, Base)
-      end
-
-      def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
-        if klass.method_defined?(name) || klass.private_method_defined?(name)
-          if superklass.method_defined?(name) || superklass.private_method_defined?(name)
-            klass.instance_method(name).owner != superklass.instance_method(name).owner
-          else
-            true
-          end
-        else
-          false
-        end
-      end
-
-      private
-
-        # @param name [Symbol] name of the attribute to generate
-        def generate_method(name)
-          generated_attribute_methods.synchronize do
-            define_attribute_methods name
-          end
-        end
-    end
   end
 end

data/lib/active_fedora/attribute_methods/read.rb

@@ -1,61 +1,46 @@
 module ActiveFedora
   module AttributeMethods
     module Read
-      ReaderMethodCache = Class.new(AttributeMethodCache) do
-                            private
-
-        # We want to generate the methods via module_eval rather than
-        # define_method, because define_method is slower on dispatch.
-        # Evaluating many similar methods may use more memory as the instruction
-        # sequences are duplicated and cached (in MRI).  define_method may
-        # be slower on dispatch, but if you're careful about the closure
-        # created, then define_method will consume much less memory.
-        #
-        # But sometimes the database might return columns with
-        # characters that are not allowed in normal method names (like
-        # 'my_column(omg)'. So to work around this we first define with
-        # the __temp__ identifier, and then use alias method to rename
-        # it to what we want.
-        #
-        # We are also defining a constant to hold the frozen string of
-        # the attribute name. Using a constant means that we do not have
-        # to allocate an object on each call to the attribute method.
-        # Making it frozen means that it doesn't get duped when used to
-        # key the @attributes_cache in read_attribute.
-        def method_body(method_name, const_name)
-          <<-EOMETHOD
-          def #{method_name}
-            name = ::ActiveFedora::AttributeMethods::AttrNames::ATTR_#{const_name}
-            read_attribute(name) { |n| missing_attribute(n, caller) }
+      module ClassMethods
+        protected
+
+          def define_method_attribute(name)
+            name = name.to_s
+            safe_name = name.unpack('h*'.freeze).first
+            temp_method = "__temp__#{safe_name}"
+
+            ActiveFedora::AttributeMethods::AttrNames.set_name_cache safe_name, name
+
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+              def #{temp_method}
+                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+                _read_attribute(name) { |n| missing_attribute(n, caller) }
+              end
+            STR
+
+            generated_attribute_methods.module_eval do
+              alias_method name, temp_method
+              undef_method temp_method
+            end
           end
-          EOMETHOD
-        end
-      end.new
+      end
 
       extend ActiveSupport::Concern
 
       # Returns the value of the attribute identified by <tt>attr_name</tt> after
       # it has been typecast (for example, "2004-12-12" in a date column is cast
       # to a date object, like Date.new(2004, 12, 12)).
-      def read_attribute(attr_name)
+      def read_attribute(attr_name, &block)
         name = attr_name.to_s
-        @attributes.fetch(name, nil)
+        _read_attribute(name, &block)
       end
 
-      private
-
-        def attribute(attribute_name)
-          read_attribute(attribute_name)
-        end
+      def _read_attribute(attr_name) # :nodoc:
+        @attributes.fetch(attr_name.to_s) { |n| yield n if block_given? }
+      end
 
-        module ClassMethods
-          def define_method_attribute(name)
-            method = ReaderMethodCache[name.to_s]
-            generated_attribute_methods.module_eval do
-              define_method name, method
-            end
-          end
-        end
+      alias attribute _read_attribute
+      private :attribute
     end
   end
 end