active-fedora 6.8.0 → 7.0.0.pre1

data/lib/active_fedora/callbacks.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/array/wrap'
-
 module ActiveFedora
   # = Active Fedora Callbacks, adapted from ActiveRecord
   #
@@ -234,7 +232,7 @@ module ActiveFedora
 
   private
 
-    def persist #:nodoc:
+    def persist(should_update_index) #:nodoc:
       run_callbacks(:save) { super }
     end
 

data/lib/active_fedora/content_model.rb

@@ -21,6 +21,22 @@ module ActiveFedora
       obj.relationships(:has_model)
     end
     
+    def self.best_model_for(obj)
+      best_model_match = obj.class unless obj.instance_of? ActiveFedora::Base
+
+      known_models_for(obj).each do |model_value|
+        # If this is of type ActiveFedora::Base, then set to the first found :has_model.
+        best_model_match ||= model_value
+
+        # If there is an inheritance structure, use the most specific case.
+        if best_model_match > model_value
+          best_model_match = model_value
+        end
+      end
+
+      best_model_match
+    end
+
     # returns an array of the model classes that are defined in the current 
     # application that the given object asserts (ie. if the object asserts 
     # a StreamingVideo model but the application doesn't define a 

data/lib/active_fedora/core.rb

@@ -0,0 +1,151 @@
+module ActiveFedora
+  module Core
+    extend ActiveSupport::Concern
+    
+    attr_reader :inner_object
+
+    # Constructor.  You may supply a custom +:pid+, or we call 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
+    # +:namespace+ value to Fedora::Repository.nextid to generate the next pid available within
+    # the given namespace.
+    def initialize(attrs = nil)
+      attrs = {} if attrs.nil?
+      @association_cache = {}
+      attributes = attrs.dup
+      @inner_object = UnsavedDigitalObject.new(self.class, attributes.delete(:namespace), attributes.delete(:pid))
+      self.relationships_loaded = true
+      load_datastreams
+
+      [:new_object,:create_date, :modified_date].each { |k| attributes.delete(k)}
+      self.attributes=attributes
+      run_callbacks :initialize
+    end
+
+    # Reloads the object from Fedora.
+    def reload
+      raise ActiveFedora::ObjectNotFoundError, "Can't reload an object that hasn't been saved" unless persisted?
+      clear_association_cache
+      clear_relationships
+      init_with(self.class.find(self.pid).inner_object)
+    end
+
+    # Initialize an empty model object and set the +inner_obj+
+    # example:
+    #
+    #   class Post < ActiveFedora::Base
+    #     has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream
+    #   end
+    #
+    #   post = Post.allocate
+    #   post.init_with(DigitalObject.find(pid))
+    #   post.properties.title # => 'hello world'
+    def init_with(inner_obj)
+      @association_cache = {}
+      @inner_object = inner_obj
+      unless @inner_object.is_a? SolrDigitalObject
+        @inner_object.original_class = self.class
+        ## Replace existing unchanged datastreams with the definitions found in this class if they have a different type.
+        ## Any datastream that is deleted here will cause a reload from fedora, so avoid it whenever possible
+        ds_specs.keys.each do |key|
+          if @inner_object.datastreams[key] != nil && !@inner_object.datastreams[key].content_changed? && @inner_object.datastreams[key].class != self.class.ds_specs[key][:type]
+            @inner_object.datastreams.delete(key)
+          end
+        end
+      end
+      load_datastreams
+      run_callbacks :find
+      run_callbacks :initialize
+      self
+    end
+
+    def ==(comparison_object)
+         comparison_object.equal?(self) ||
+           (comparison_object.instance_of?(self.class) &&
+             comparison_object.pid == pid &&
+             !comparison_object.new_record?)
+    end
+
+    def clone
+      new_object = self.class.create
+      clone_into(new_object)
+    end
+
+    # Clone the datastreams from this object into the provided object, while preserving the pid of the provided object
+    # @param [Base] new_object clone into this object
+    def clone_into(new_object)
+      rels = Nokogiri::XML( rels_ext.content)
+      rels.xpath("//rdf:Description/@rdf:about").first.value = new_object.internal_uri
+      new_object.rels_ext.content = rels.to_xml
+
+      datastreams.each do |k, v|
+        next if k == 'RELS-EXT'
+        new_object.datastreams[k].content = v.content
+      end
+      new_object if new_object.save
+    end
+
+    def pretty_pid
+      if self.pid == UnsavedDigitalObject::PLACEHOLDER
+        nil
+      else
+        self.pid
+      end
+    end
+
+    # This method adapts the inner_object to a new ActiveFedora::Base implementation
+    # This is intended to minimize redundant interactions with Fedora
+    def adapt_to(klass)
+      unless klass.ancestors.include? ActiveFedora::Base
+        raise "Cannot adapt #{self.class.name} to #{klass.name}: Not a ActiveFedora::Base subclass"
+      end
+      klass.allocate.init_with(inner_object)
+    end
+
+    # Examines the :has_model assertions in the RELS-EXT.
+    #
+    # If the object is of type ActiveFedora::Base, then use the first :has_model
+    # in the RELS-EXT for this object. Due to how the RDF writer works, this is
+    # currently just the first alphabetical model.
+    #
+    # If the object was instantiated with any other class, then use that class
+    # as the base of the type the user wants rather than casting to the first
+    # :has_model found on the object.
+    #
+    # In either case, if an extended model of that initial base model of the two
+    # cases above exists in the :has_model, then instantiate as that extended
+    # model type instead.
+    def adapt_to_cmodel
+      best_model_match = ActiveFedora::ContentModel.best_model_for(self)
+
+      self.instance_of?(best_model_match) ? self : self.adapt_to(best_model_match)
+    end
+    
+    # ** EXPERIMENTAL **
+    # This method returns a new object of the same class, with the internal SolrDigitalObject
+    # replaced with an actual DigitalObject.
+    def reify
+      if self.inner_object.is_a? DigitalObject
+        raise "#{self.inspect} is already a full digital object"
+      end
+      self.class.find self.pid
+    end
+    
+    # ** EXPERIMENTAL **
+    # This method reinitializes a lightweight, loaded-from-solr object with an actual
+    # DigitalObject inside.
+    def reify!
+      if self.inner_object.is_a? DigitalObject
+        raise "#{self.inspect} is already a full digital object"
+      end
+      self.init_with DigitalObject.find(self.class,self.pid)
+    end
+    
+    module ClassMethods
+      private
+      def relation
+        Relation.new(self)
+      end
+    end
+  end
+end

data/lib/active_fedora/datastream_attribute.rb

@@ -0,0 +1,76 @@
+module ActiveFedora
+  # Represents the mapping between a model attribute and a field in a datastream
+  class DatastreamAttribute
+    
+    attr_accessor :dsid, :field, :klass, :at, :reader, :writer, :multiple
+
+    def initialize(field, dsid, klass, args={})
+      self.field = field
+      self.dsid = dsid
+      self.klass = klass
+      self.multiple = args[:multiple].nil? ? false : args[:multiple]
+      self.at = args[:at]
+
+      initialize_reader!
+      initialize_writer!
+    end
+
+    # Gives the primary solr name for a column. If there is more than one indexer on the field definition, it gives the first 
+    def primary_solr_name
+      if klass.respond_to?(:primary_solr_name)
+        klass.primary_solr_name(dsid, field)
+      else
+        raise IllegalOperation, "the class '#{klass}' doesn't respond to 'primary_solr_name'"
+      end
+    end
+
+    def type
+      if klass.respond_to?(:type)
+        klass.type(field)
+      else
+        raise IllegalOperation, "the class '#{klass}' doesn't respond to 'type'"
+      end
+    end
+
+    private
+
+    def initialize_writer!
+      this = self
+      self.writer = lambda do |v|
+        ds = datastream_for_attribute(this.dsid)
+        mark_as_changed(this.field) if value_has_changed?(this.field, v)
+        if ds.kind_of?(ActiveFedora::RDFDatastream)
+          ds.send("#{this.field}=", v)
+        else
+          terminology = this.at || [this.field]
+          ds.send(:update_indexed_attributes, {terminology => v})
+        end
+      end
+    end
+
+    def initialize_reader!
+      this = self
+      self.reader = lambda do |*opts|
+        if inner_object.is_a? SolrDigitalObject
+          # Look in the cache
+          # TODO catch a non-cached error and try fedora.
+          inner_object.fetch(this.field)
+        else
+          # Load from fedora
+          ds = datastream_for_attribute(this.dsid)
+          if ds.kind_of?(ActiveFedora::RDFDatastream)
+            ds.send(this.field)
+          else
+            terminology = this.at || [this.field]
+            if terminology.length == 1 && opts.present?
+              ds.send(terminology.first, *opts)
+            else
+              ds.send(:term_values, *terminology)
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/active_fedora/datastream_hash.rb

@@ -1,14 +1,9 @@
-require 'forwardable'
-
 module ActiveFedora
-  class DatastreamHash
-    extend Forwardable
-
-    def_delegators :@hash, *(Hash.instance_methods(false))
-
-    def initialize (obj, &block)
+  class DatastreamHash < Hash
+    
+    def initialize (obj)
       @obj = obj
-      @hash = Hash.new &block
+      super()
     end
 
     def [] (key)
@@ -16,12 +11,12 @@ module ActiveFedora
         ds = Datastream.new(@obj.inner_object, key, :controlGroup=>'X')
         self[key] = ds
       end
-      @hash[key]
+      super
     end 
 
     def []= (key, val)
-      @obj.inner_object.datastreams[key]=val
-      @hash[key]=val
-    end
+      @obj.inner_object.datastreams[key]=val# unless @obj.inner_object.new?
+      super
+    end 
   end
 end

data/lib/active_fedora/datastreams.rb

@@ -16,7 +16,7 @@ module ActiveFedora
       end
 
       before_save :add_disseminator_location_to_datastreams
-      before_save :serialize_datastreams
+      #before_save :serialize_datastreams
     end
 
     def ds_specs
@@ -38,16 +38,6 @@ module ActiveFedora
       true
     end
 
-    ## Given a method name, return the best-guess dsid
-    def corresponding_datastream_name(method_name)
-      dsid = method_name.to_s
-      return dsid if datastreams.has_key? dsid
-      unescaped_name = method_name.to_s.gsub('_', '-')
-      return unescaped_name if datastreams.has_key? unescaped_name
-      nil
-    end
-
-    
     #
     # Datastream Management
     #
@@ -72,7 +62,7 @@ module ActiveFedora
     end
 
     def datastream_from_spec(ds_spec, name)
-      inner_object.datastream_object_for name, {}, ds_spec
+      inner_object.datastream_object_for name, ds_spec
     end
 
     def load_datastreams
@@ -99,10 +89,10 @@ module ActiveFedora
         datastream.instance_variable_set :@dsid, generate_dsid(prefix)
       end
       datastreams[datastream.dsid] = datastream
-      return datastream.dsid
+      datastream.dsid
     end
 
-    #return all datastreams of type ActiveFedora::RDFDatastream or ActiveFedora::NokogiriDatastream
+    # @return [Array] all datastreams that return true for `metadata?` and are not Rels-ext
     def metadata_streams
       datastreams.select { |k, ds| ds.metadata? }.reject { |k, ds| ds.kind_of?(ActiveFedora::RelsExtDatastream) }.values
     end
@@ -120,13 +110,6 @@ module ActiveFedora
       sprintf("%s%i", prefix,suffix)
     end    
 
-    # Return the Dublin Core (DC) Datastream. You can also get at this via 
-    # the +datastreams["DC"]+.
-    def dc
-      Deprecation.warn(Datastreams, 'dc is deprecated. Consider using Base#datastreams["DC"] instead.', caller)
-      return datastreams["DC"] 
-    end
-
     # Returns the RELS-EXT Datastream
     # Tries to grab from in-memory datastreams first
     # Failing that, attempts to load from Fedora and addst to in-memory datastreams
@@ -161,7 +144,9 @@ module ActiveFedora
       attrs[:checksumType] = opts[:checksumType] if opts[:checksumType]
       attrs[:versionable] = opts[:versionable] unless opts[:versionable].nil?
       ds = create_datastream(self.class.datastream_class_for_name(opts[:dsid]), opts[:dsid], attrs)
-      add_datastream(ds)
+      add_datastream(ds).tap do |dsid|
+        self.class.build_datastream_accessor(dsid) unless respond_to? dsid
+      end
     end
     
     
@@ -189,10 +174,16 @@ module ActiveFedora
     end
 
     module ClassMethods
-      #This method is used to specify the details of a datastream. 
+      # @param [String] dsid the datastream id
+      # @returns [Class] the class of the datastream
+      def datastream_class_for_name(dsid)
+        ds_specs[dsid] ? ds_specs[dsid].fetch(:type, ActiveFedora::Datastream) : ActiveFedora::Datastream
+      end
+
+      # This method is used to specify the details of a datastream. 
       # You can pass the name as the first argument and a hash of options as the second argument
       # or you can pass the :name as a value in the args hash. Either way, name is required.
-      # Note that this method doesn't actually execute the block, but stores it , to be executed
+      # Note that this method doesn't actually execute the block, but stores it, to be executed
       # by any the implementation of the datastream(specified as :type)
       #
       # @param [Hash] args 
@@ -217,8 +208,12 @@ module ActiveFedora
         
         
         spec = {:autocreate => args.fetch(:autocreate, false), :type => args[:type], :label =>  args.fetch(:label,""), :control_group => args[:control_group], :disseminator => args.fetch(:disseminator,""), :url => args.fetch(:url,""),:block => block}
+        name = args[:name]
+        raise ArgumentError, "You must provide a name (dsid) for the metadata datastream" unless name
+        raise ArgumentError, "You must provide a :type property for the metadata datastream '#{name}'" unless spec[:type]
         spec[:versionable] = args[:versionable] if args.has_key? :versionable
-        ds_specs[args[:name]]= spec
+        build_datastream_accessor(name)
+        ds_specs[name]= spec
       end
 
       
@@ -251,8 +246,26 @@ module ActiveFedora
         spec = {:autocreate => args.fetch(:autocreate, false), :type => args.fetch(:type,ActiveFedora::Datastream),
                 :label =>  args.fetch(:label,"File Datastream"), :control_group => args.fetch(:control_group,"M")}
         spec[:versionable] = args[:versionable] if args.has_key? :versionable
-        ds_specs[args.fetch(:name, "content")]= spec
+        name = args.fetch(:name, "content")
+        build_datastream_accessor(name)
+        ds_specs[name]= spec
       end
+
+      def build_datastream_accessor(dsid)
+        name = name_for_dsid(dsid)
+        define_method name do
+          datastreams[dsid]
+        end
+        end
+
+
+      private
+
+        ## Given a dsid return a standard name
+        def name_for_dsid(dsid)
+          dsid.gsub('-', '_')
+        end
+
     end
 
   end

data/lib/active_fedora/digital_object.rb

@@ -4,10 +4,10 @@ module ActiveFedora
     attr_accessor :original_class
     
     module DatastreamBootstrap
-      def datastream_object_for dsid, options={}, ds_spec=nil
+      def datastream_object_for dsid, ds_spec=nil
         # ds_spec is nil when called from Rubydora for existing datastreams, so it should not be autocreated
         ds_spec ||= (original_class.ds_specs[dsid] || {}).merge(:autocreate=>false)
-        ds = ds_spec.fetch(:type, ActiveFedora::Datastream).new(self, dsid, options)
+        ds = ds_spec.fetch(:type, ActiveFedora::Datastream).new(self, dsid)
         attributes = {}
         attributes[:asOfDateTime] ||= asOfDateTime if self.respond_to? :asOfDateTime
         attributes[:dsLabel] = ds_spec[:label] if ds_spec[:label].present?

data/lib/active_fedora/fedora_attributes.rb

@@ -0,0 +1,45 @@
+module ActiveFedora
+  module FedoraAttributes
+
+    delegate :state=, :label=, to: :inner_object
+
+    #return the pid of the Fedora Object
+    # if there is no fedora object (loaded from solr) get the instance var
+    # TODO make inner_object a proxy that can hold the pid
+    def pid
+       @inner_object.pid
+    end
+
+    def id   ### Needed for the nested form helper
+      self.pid
+    end
+
+    #return the owner id
+    def owner_id
+      Array(@inner_object.ownerId).first
+    end
+    
+    def owner_id=(owner_id)
+      @inner_object.ownerId=(owner_id)
+    end
+
+    def label
+      Array(@inner_object.label).first
+    end
+
+    def state
+      Array(@inner_object.state).first
+    end
+
+    #return the create_date of the inner object (unless it's a new object)
+    def create_date
+      @inner_object.new_record? ?  Time.now : Array(@inner_object.createdDate).first
+    end
+
+    #return the modification date of the inner object (unless it's a new object)
+    def modified_date
+      @inner_object.new_record? ? Time.now : Array(@inner_object.lastModifiedDate).first
+    end
+
+  end
+end