active-fedora 2.3.8 → 3.0.0

data/lib/active_fedora/associations/association_proxy.rb

@@ -0,0 +1,177 @@
+module ActiveFedora
+  module Associations
+    # This is the root class of all association proxies:
+    #
+    #   AssociationProxy
+    #     BelongsToAssociation
+    #     AssociationCollection
+    #       HasManyAssociation
+    #
+    # Association proxies in Active Fedora are middlemen between the object that
+    # holds the association, known as the <tt>@owner</tt>, and the actual associated
+    # object, known as the <tt>@target</tt>. The kind of association any proxy is
+    # about is available in <tt>@reflection</tt>. That's an instance of the class
+    # ActiveFedora::Reflection::AssociationReflection.
+    #
+    # For example, given
+    #
+    #   class Blog < ActiveFedora::Base
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.find('changeme:123')
+    #
+    # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
+    # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
+    # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
+    #
+    # This class has most of the basic instance methods removed, and delegates
+    # unknown methods to <tt>@target</tt> via <tt>method_missing</tt>. As a
+    # corner case, it even removes the +class+ method and that's why you get
+    #
+    #   blog.posts.class # => Array
+    #
+    # though the object behind <tt>blog.posts</tt> is not an Array, but an
+    # ActiveFedora::Associations::HasManyAssociation.
+
+    class AssociationProxy
+       delegate :to_param, :to=>:target
+
+       def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+        @updated = false
+        # reflection.check_validity!
+        # Array.wrap(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
+        reset
+      end
+
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @loaded = false
+        @target = nil
+      end
+
+      # Reloads the \target and returns +self+ on success.
+      def reload
+        reset
+        load_target
+        self unless @target.nil?
+      end
+
+      # Has the \target been already \loaded?
+      def loaded?
+        @loaded
+      end
+
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded
+        @loaded = true
+      end
+
+      # Returns the target of this proxy, same as +proxy_target+.
+      def target
+        @target
+      end
+
+      # Sets the target of this proxy to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+        loaded
+      end
+
+      # # Forwards the call to the target. Loads the \target if needed.
+      # def inspect
+      #   load_target
+      #   @target.inspect
+      # end
+
+      protected
+
+
+        # Assigns the ID of the owner to the corresponding foreign key in +record+.
+        # If the association is polymorphic the type of the owner is also set.
+        def set_belongs_to_association_for(record)
+          unless @owner.new_record?
+            record.add_relationship(@reflection.options[:property], @owner)
+          end
+        end
+
+
+      private
+        def method_missing(method, *args)
+          if load_target
+            unless @target.respond_to?(method)
+              message = "undefined method `#{method.to_s}' for \"#{@target}\":#{@target.class.to_s}"
+              raise NoMethodError, message
+            end
+
+            if block_given?
+              @target.send(method, *args)  { |*block_args| yield(*block_args) }
+            else
+              @target.send(method, *args)
+            end
+          end
+        end
+
+
+        # Loads the \target if needed and returns it.
+        #
+        # This method is abstract in the sense that it relies on +find_target+,
+        # which is expected to be provided by descendants.
+        #
+        # If the \target is already \loaded it is just returned. Thus, you can call
+        # +load_target+ unconditionally to get the \target.
+        #
+        # ActiveFedora::RecordNotFound is rescued within the method, and it is
+        # not reraised. The proxy is \reset and +nil+ is the return value.
+        def load_target
+          return nil unless defined?(@loaded)
+
+          if !loaded? and (!@owner.new_record? || foreign_key_present)
+            @target = find_target
+          end
+
+          if @target.nil?
+            reset
+          else
+            @loaded = true
+            @target
+          end
+        end
+
+        # Can be overwritten by associations that might have the foreign key
+        # available for an association without having the object itself (and
+        # still being a new record). Currently, only +belongs_to+ presents
+        # this scenario.
+        def foreign_key_present
+          false
+        end
+
+
+
+        # Raises ActiveFedora::AssociationTypeMismatch unless +record+ is of
+        # the kind of the class of the associated objects. Meant to be used as
+        # a sanity check when you are about to assign an associated record.
+        def raise_on_type_mismatch(record)
+          unless record.is_a?(@reflection.klass) || record.is_a?(@reflection.class_name.constantize)
+            message = "#{@reflection.class_name}(##{@reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise ActiveFedora::AssociationTypeMismatch, message
+          end
+        end
+
+
+        if RUBY_VERSION < '1.9.2'
+          # Array#flatten has problems with recursive arrays before Ruby 1.9.2.
+          # Going one level deeper solves the majority of the problems.
+          def flatten_deeper(array)
+            array.collect { |element| (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element }.flatten
+          end
+        else
+          def flatten_deeper(array)
+            array.flatten
+          end
+        end
+
+    end
+  end
+end

data/lib/active_fedora/associations/belongs_to_association.rb

@@ -0,0 +1,36 @@
+module ActiveFedora
+  module Associations
+    class BelongsToAssociation < AssociationProxy #:nodoc:
+      def replace(record)
+        if record.nil?
+          ### TODO a more efficient way of doing this would be to write a clear_relationship method
+          old_record = find_target
+          @owner.remove_relationship(@reflection.options[:property], old_record) unless old_record.nil?
+        else
+          raise_on_type_mismatch(record)
+
+          ### TODO a more efficient way of doing this would be to write a clear_relationship method
+          old_record = find_target
+          @owner.remove_relationship(@reflection.options[:property], old_record) unless old_record.nil?
+
+          @target = (AssociationProxy === record ? record.target : record)
+          @owner.add_relationship(@reflection.options[:property], record) unless record.new_record?
+          @updated = true
+        end
+
+        loaded
+        record
+      end
+
+      private
+        def find_target
+          @owner.load_outbound_relationship(@reflection.name.to_s, @reflection.options[:property]).first
+        end
+
+        def foreign_key_present
+          !@owner.send(@reflection.primary_key_name).nil?
+        end
+
+    end
+  end
+end

data/lib/active_fedora/associations/has_many_association.rb

@@ -0,0 +1,52 @@
+module ActiveFedora
+  module Associations
+    class HasManyAssociation < AssociationCollection #:nodoc:
+      def initialize(owner, reflection)
+        super
+      end
+
+      # Returns the number of records in this collection.
+      #
+      # That does not depend on whether the collection has already been loaded
+      # or not. The +size+ method is the one that takes the loaded flag into
+      # account and delegates to +count_records+ if needed.
+      #
+      # If the collection is empty the target is set to an empty array and
+      # the loaded flag is set to true as well.
+      def count_records
+        count = if @target
+          @target.size
+        else
+          0
+        end
+
+        # If there's nothing in the database and @target has no new records
+        # we are certain the current target is an empty array. This is a
+        # documented side-effect of the method that may avoid an extra SELECT.
+        @target ||= [] and loaded if count == 0
+
+        return count
+      end
+
+      def insert_record(record, force = false, validate = true)
+        set_belongs_to_association_for(record)
+        #force ? record.save! : record.save(:validate => validate)
+        record.save
+      end
+
+      protected
+
+        # Deletes the records according to the <tt>:dependent</tt> option.
+        def delete_records(records)
+          records.each do |r| 
+            r.remove_relationship(@reflection.options[:property], @owner)
+          end
+        end
+
+
+
+    end
+
+  end
+
+end

data/lib/active_fedora/attribute_methods.rb

@@ -0,0 +1,8 @@
+module ActiveFedora
+  module AttributeMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+    end
+  end
+end

data/lib/active_fedora/base.rb

@@ -1,10 +1,11 @@
-require 'util/class_level_inheritable_attributes'
-require 'active_fedora/model'
-require 'active_fedora/semantic_node'
 require "solrizer"
 require 'nokogiri'
 require "loggable"
-require 'benchmark'
+
+#require 'active_support/core_ext/kernel/singleton_class'
+#require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/class/inheritable_attributes'
+#require 'active_support/inflector'
 
 SOLR_DOCUMENT_ID = "id" unless (defined?(SOLR_DOCUMENT_ID) && !SOLR_DOCUMENT_ID.nil?)
 ENABLE_SOLR_UPDATES = true unless defined?(ENABLE_SOLR_UPDATES)
@@ -32,13 +33,11 @@ module ActiveFedora
   # =Implementation
   # This class is really a facade for a basic Fedora::FedoraObject, which is stored internally.
   class Base
-    include MediaShelfClassLevelInheritableAttributes
-    ms_inheritable_attributes  :ds_specs, :class_named_datastreams_desc
-    include Model
+    include RelationshipsHelper
     include SemanticNode
-    include Solrizer::FieldNameMapper
-    include Loggable
-    
+    class_inheritable_accessor  :ds_specs, :class_named_datastreams_desc
+    self.class_named_datastreams_desc = {}
+    self.ds_specs = {}
     attr_accessor :named_datastreams_desc
     
 
@@ -56,7 +55,22 @@ module ActiveFedora
       @new_object = bool
       inner_object.new_object = bool
     end
-    
+
+    ## Required by associations
+    def new_record?
+      self.new_object?
+    end
+
+    def persisted?
+      !new_object?
+    end
+
+    def attributes=(properties)
+      properties.each do |k, v|
+        respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(UnknownAttributeError, "unknown attribute: #{k}")
+      end
+    end
+
     # Constructor. If +attrs+  does  not comtain +:pid+, we assume we're making a new one,
     # and call off to the Fedora Rest API for the next available Fedora pid, and mark as new object.
     # Also, if +attrs+ does not contain +:pid+ but does contain +:namespace+ it will pass the
@@ -65,7 +79,8 @@ module ActiveFedora
     # 
     # If there is a pid, we're re-hydrating an existing object, and new object is false. Once the @inner_object is stored,
     # we configure any defined datastreams.
-    def initialize(attrs = {})
+    def initialize(attrs = nil)
+      attrs = {} if attrs.nil?
       unless attrs[:pid]
         if attrs[:namespace]
           attrs = attrs.merge!({:pid=>Fedora::Repository.instance.nextid({:namespace=>attrs[:namespace]})})
@@ -79,6 +94,10 @@ module ActiveFedora
       @inner_object = Fedora::FedoraObject.new(attrs)
       @datastreams = {}
       configure_defined_datastreams
+
+      attributes = attrs.dup
+      [:pid, :namespace, :new_object,:create_date, :modified_date].each { |k| attributes.delete(k)}
+      self.attributes=attributes
     end
 
     #This method is used to specify the details of a datastream. 
@@ -86,18 +105,19 @@ module ActiveFedora
     #execute the block, but stores it at the class level, to be executed
     #by any future instantiations.
     def self.has_metadata(args, &block)
-      @ds_specs ||= Hash.new
-      @ds_specs[args[:name]]= [args[:type], args.fetch(:label,""), block]
+      #@ds_specs ||= Hash.new
+      ds_specs[args[:name]]= [args[:type], args.fetch(:label,""), block]
     end
 
     def method_missing(name, *args)
       if datastreams.has_key? name.to_s
         ### Create and invoke a proxy method 
         self.class.class_eval <<-end_eval
-          def #{name}()
+          def #{name.to_s}()
             datastreams["#{name.to_s}"]
           end
         end_eval
+
         self.send(name)
       else 
         super
@@ -123,12 +143,8 @@ module ActiveFedora
     # Refreshes the object's info from Fedora
     # Note: Currently just registers any new datastreams that have appeared in fedora
     def refresh
-      ms = 1000 * Benchmark.realtime do
-        inner_object.load_attributes_from_fedora
-        @datastreams = datastreams_in_fedora.merge(datastreams_in_memory)
-      end
-      logger.debug "refreshing #{pid} took #{ms} ms"
-      @datastreams
+      inner_object.load_attributes_from_fedora
+      @datastreams = datastreams_in_fedora.merge(datastreams_in_memory)
     end
 
     #Deletes a Base object, also deletes the info indexed in Solr, and 
@@ -713,7 +729,7 @@ module ActiveFedora
     #
     # This hash is later used when adding a named datastream such as an "audio_file" as defined above.
     def self.named_datastreams_desc
-      @class_named_datastreams_desc ||= {}
+      self.class_named_datastreams_desc ||= {}
     end
 
     # 
@@ -762,11 +778,16 @@ module ActiveFedora
     def pid
       @inner_object.pid
     end
-    
-    #For Rails compatibility with url generators.
-    def to_param
+
+
+    def id   ### Needed for the nested form helper
       self.pid
     end
+    
+    def to_key
+      persisted? ? [pid] : nil
+    end
+
     #return the internal fedora URI
     def internal_uri
       "info:fedora/#{pid}"
@@ -950,50 +971,18 @@ module ActiveFedora
     def update_index
       if defined?( Solrizer::Fedora::Solrizer ) 
         #logger.info("Trying to solrize pid: #{pid}")
-        ms = 1000 * Benchmark.realtime do
-          solrizer = Solrizer::Fedora::Solrizer.new
-          solrizer.solrize( self )
-        end
-        logger.debug "solrize for #{pid} took #{ms} ms"
+        solrizer = Solrizer::Fedora::Solrizer.new
+        solrizer.solrize( self )
       else
         #logger.info("Trying to update solr for pid: #{pid}")
-        ms = 1000 * Benchmark.realtime do
-          SolrService.instance.conn.update(self.to_solr)
-        end
-        logger.debug "solr update for #{pid} took #{ms} ms"
+        SolrService.instance.conn.update(self.to_solr)
       end
     end
 
-    # An ActiveRecord-ism to udpate metadata values.
-    #
-    # Example Usage:
-    #
-    # m.update_attributes(:fubar=>'baz')
-    #
-    # This will attempt to set the values for any fields named fubar in any of 
-    # the object's datastreams. This means DS1.fubar_values and DS2.fubar_values 
-    # are _both_ overwritten.  
-    #
-    # If you want to specify which datastream(s) to update,
-    # use the :datastreams argument like so:
-    #  m.update_attributes({:fubar=>'baz'}, :datastreams=>"my_ds")
-    # or
-    #  m.update_attributes({:fubar=>'baz'}, :datastreams=>["my_ds", "my_other_ds"])
-    def update_attributes(params={}, opts={})
-      result = {}
-      if opts[:datastreams]
-        ds_array = []
-        opts[:datastreams].each do |dsname|
-          ds_array << datastreams[dsname]
-        end
-      else
-        ds_array = metadata_streams
-      end
-      ds_array.each do |d|
-        ds_result = d.update_attributes(params,opts)
-        result[d.dsid] = ds_result
-      end
-      return result
+
+    def update_attributes(properties)
+      self.attributes=properties
+      save
     end
 
     # A convenience method  for updating indexed attributes.  The passed in hash
@@ -1101,25 +1090,32 @@ module ActiveFedora
     
     # Pushes the object and all of its new or dirty datastreams into Fedora
     def update
-      result = nil
-      ms = 1000 * Benchmark.realtime do
-        result = Fedora::Repository.instance.save(@inner_object)      
-      end
-      logger.debug "instance save for #{pid} took #{ms} ms"
-      ms = 1000 * Benchmark.realtime do
-        datastreams_in_memory.each do |k,ds|
-          if ds.dirty? || ds.new_object? 
-            if ds.class.included_modules.include?(ActiveFedora::MetadataDatastreamHelper) || ds.instance_of?(ActiveFedora::RelsExtDatastream)
-              @metadata_is_dirty = true
-            end
-            result = ds.save
-          end 
-        end
-        refresh
+      result = Fedora::Repository.instance.save(@inner_object)      
+      datastreams_in_memory.each do |k,ds|
+        if ds.dirty? || ds.new_object? 
+          if ds.class.included_modules.include?(ActiveFedora::MetadataDatastreamHelper) || ds.instance_of?(ActiveFedora::RelsExtDatastream)
+          # if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::NokogiriDatastream) || ds.instance_of?(ActiveFedora::RelsExtDatastream)
+            @metadata_is_dirty = true
+          end
+          result = ds.save
+        end 
       end
-      logger.debug "datastream save for #{pid} took #{ms} ms"
+      refresh
       return result
     end
 
   end
+
+  Base.class_eval do
+    include Model
+    include Solrizer::FieldNameMapper
+    include Loggable
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+    include Delegating
+    include Associations
+    include NestedAttributes
+    include Reflection
+  end
+
 end