active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/datastream.rb

@@ -1,122 +1,9 @@
 module ActiveFedora
+  class Datastream < File
+    extend Deprecation
 
-  # This class represents a Fedora datastream
-  class Datastream < Rubydora::Datastream
-
-    attr_writer :digital_object
-    attr_accessor :last_modified
-
-    # @param digital_object [DigitalObject] the digital object that this object belongs to
-    # @param dsid [String] the datastream id, if this is nil, a datastream id will be generated.
-    # @param options [Hash]
-    # @option options [String,IO] :content the content for the datastream
-    # @option options [String] :dsLabel label for the datastream
-    # @option options [String] :dsLocation location for an external or redirect datastream
-    # @option options [String] :controlGroup a controlGroup for the datastream
-    # @option options [String] :mimeType the mime-type of the content
-    # @option options [String] :prefix the prefix for the auto-generated DSID (not to be confused with the solr prefix)
-    # @option options [Boolean] :versionable is the datastream versionable
-    def initialize(digital_object=nil, dsid=nil, options={})
-      prefix = options.delete(:prefix)
-      dsid = nil if dsid == ''
-      dsid ||= generate_dsid(digital_object, prefix || "DS")
-      super(digital_object, dsid, options)
-    end
-
-    alias_method :realLabel, :label
-
-    def label
-      Array(realLabel).first
-    end
-    alias_method :dsLabel, :label
-
-    def inspect
-      "#<#{self.class} @pid=\"#{digital_object ? pid : nil}\" @dsid=\"#{dsid}\" @controlGroup=\"#{controlGroup}\" changed=\"#{changed?}\" @mimeType=\"#{mimeType}\" >"
-    end
-
-    #compatibility method for rails' url generators. This method will 
-    #urlescape escape dots, which are apparently
-    #invalid characters in a dsid.
-    def to_param
-      dsid.gsub(/\./, '%2e')
-    end
-    
-    # @abstract Override this in your concrete datastream class. 
-    # @return [boolean] does this datastream contain metadata (not file data)
-    def metadata?
-      false
-    end
-
-    def save
-      super
-      self
-    end
-
-    def create
-      super
-      self
-    end
-
-    # Freeze datastreams such that they can be loaded from Fedora, but can't be changed
-    def freeze
-      @frozen = true
-    end
-
-    def frozen?
-      !!@frozen
-    end
-
-    # serializes any changed data into the content field
-    def serialize!
-    end
-    
-    def solrize_profile # :nodoc:
-      profile_hash = {}
-      profile.each_pair do |property,value|
-        if property =~ /Date/
-          value = Time.parse(value) unless value.is_a?(Time)
-          value = value.xmlschema
-        end
-        profile_hash[property] = value
-      end
-      profile_hash
-    end
-    
-    def profile_from_hash(profile_hash)
-      profile_hash.each_pair do |key,value|
-        profile[key] = value
-      end
-    end
-    
-    def to_solr(solr_doc = Hash.new)
-      solr_doc
+    def self.inherited(child)
+      Deprecation.warn child, "ActiveFedora::Datastream is deprecated and will be removed in active-fedora 10.0. Use ActiveFedora::File instead"
     end
-
-    protected
-
-    # return a valid dsid that is not currently in use.  Uses a prefix (default "DS") and an auto-incrementing integer
-    # Example: if there are already datastreams with IDs DS1 and DS2, this method will return DS3.  If you specify FOO as the prefix, it will return FOO1.
-    def generate_dsid(digital_object, prefix)
-      return unless digital_object
-      matches = digital_object.datastreams.keys.map {|d| data = /^#{prefix}(\d+)$/.match(d); data && data[1].to_i}.compact
-      val = matches.empty? ? 1 : matches.max + 1
-      format_dsid(prefix, val)
-    end
-    
-    ### Provided so that an application can override how generated pids are formatted (e.g DS01 instead of DS1)
-    def format_dsid(prefix, suffix)
-      sprintf("%s%i", prefix,suffix)
-    end    
-
-    # The string to prefix all solr fields with. Override this method if you want
-    # a prefix other than the default
-    def prefix
-      raise RuntimeError, "to_solr requires the dsid to be set" unless dsid
-      "#{dsid.underscore}__"
-    end
-
-  end
-  
-  class DatastreamConcurrencyException < Exception # :nodoc:
   end
 end

data/lib/active_fedora/datastreams.rb

@@ -1,269 +1,8 @@
 module ActiveFedora
   module Datastreams
-    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+    # extend Deprecation
 
     autoload :NokogiriDatastreams, 'active_fedora/datastreams/nokogiri_datastreams'
-
-    included do
-      class_attribute :ds_specs
-      self.ds_specs = {'RELS-EXT'=> {:type=> ActiveFedora::RelsExtDatastream, :label=>"Fedora Object-to-Object Relationship Metadata", :block=>nil}}
-
-      before_save :add_disseminator_location_to_datastreams
-      #before_save :serialize_datastreams
-    end
-
-    module ClassMethods
-      def inherited(kls) #:nodoc:
-        super
-        kls.ds_specs = kls.ds_specs.dup
-      end
-    end
-
-    def ds_specs
-      self.class.ds_specs
-    end
-
-    def serialize_datastreams
-      datastreams.each {|k, ds| ds.serialize! }
-    end
-
-    # Adds the disseminator location to the datastream after the pid has been established
-    def add_disseminator_location_to_datastreams
-      self.ds_specs.each do |name,ds_config|
-        ds = datastreams[name]
-        if ds && ds.controlGroup == 'E' && ds_config[:disseminator].present?
-          ds.dsLocation= "#{ActiveFedora.config_for_environment[:url]}/objects/#{pid}/methods/#{ds_config[:disseminator]}"
-        end
-      end
-      true
-    end
-
-    #
-    # Datastream Management
-    #
-    
-    # Returns all known datastreams for the object.  If the object has been 
-    # saved to fedora, the persisted datastreams will be included.
-    # Datastreams that have been modified in memory are given preference over 
-    # the copy in Fedora.
-    def datastreams
-      @datastreams ||= DatastreamHash.new(self)
-    end
-  
-    def configure_datastream(ds, ds_spec=nil)
-      ds_spec ||= self.ds_specs[ds.dsid]
-      if ds_spec
-        ds.model = self if ds_spec[:type] == RelsExtDatastream
-        # If you called has_metadata with a block, pass the block into the Datastream class
-        if ds_spec[:block].class == Proc
-          ds_spec[:block].call(ds)
-        end
-      end
-    end
-
-    def datastream_from_spec(ds_spec, name)
-      inner_object.datastream_object_for name, {}, ds_spec
-    end
-
-    def load_datastreams
-      local_ds_specs = self.ds_specs.dup
-      inner_object.datastreams.each do |dsid, ds|
-        self.add_datastream(ds)
-        configure_datastream(datastreams[dsid])
-        local_ds_specs.delete(dsid)
-      end
-      local_ds_specs.each do |name,ds_spec|
-        ds = datastream_from_spec(ds_spec, name)
-        self.add_datastream(ds)
-        configure_datastream(ds, ds_spec)
-      end
-    end      
-
-    # Adds datastream to the object.
-    # @return [String] dsid of the added datastream
-    def add_datastream(datastream, opts={})
-      datastreams[datastream.dsid] = datastream
-      datastream.dsid
-    end
-
-    # @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
-    
-
-    # 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
-    # Failing that, creates a new RelsExtDatastream and adds it to the object
-    def rels_ext
-      if !datastreams.has_key?("RELS-EXT") 
-        ds = ActiveFedora::RelsExtDatastream.new(@inner_object,'RELS-EXT')
-        ds.model = self
-        add_datastream(ds)
-      end
-      return datastreams["RELS-EXT"]
-    end
-
-    #
-    # File Management
-    #
-    
-    # Add the given file as a datastream in the object
-    #
-    # @param [File] file the file to add
-    # @param [Hash] opts options: :dsid, :label, :mimeType, :prefix, :checksumType
-    def add_file_datastream(file, opts={})
-      label = opts.has_key?(:label) ? opts[:label] : ""
-      attrs = {:dsLabel => label, :controlGroup => 'M', :blob => file, :prefix=>opts[:prefix]}
-      if opts.has_key?(:mime_type)
-        attrs.merge!({:mimeType=>opts[:mime_type]})
-      elsif opts.has_key?(:mimeType)
-        attrs.merge!({:mimeType=>opts[:mimeType]})
-      elsif opts.has_key?(:content_type)
-        attrs.merge!({:mimeType=>opts[:content_type]})
-      end
-      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).tap do |dsid|
-        self.class.build_datastream_accessor(dsid) unless respond_to? dsid
-      end
-    end
-    
-    
-    # Creates a datastream to be added to the object
-    # @param type [Class] the class of the datastream object to be created (or a String that can eval to a class)
-    # @param dsid [String] the dsid of the datastream to be created, or a generated value if false
-    # @param opts [Hash] the ds options to be assigned to the created object, cf. Rubydora::Datastream.DS_ATTRIBUTES
-    # @return [ActiveFedora::Datastream] a datastream object of the type indicated in the parameters
-    def create_datastream(type, dsid, opts={})
-      klass = type.kind_of?(Class) ? type : type.constantize
-      raise ArgumentError, "Argument dsid must be of type string" if dsid && !dsid.kind_of?(String)
-      ds = klass.new(inner_object, dsid, prefix: opts[:prefix])
-      [:mimeType, :controlGroup, :dsLabel, :dsLocation, :checksumType, :versionable].each do |key|
-        ds.send("#{key}=".to_sym, opts[key]) unless opts[key].nil?
-      end
-      if ds.managed? || ds.inline?
-        blob = opts[:blob] 
-        if blob 
-          if !ds.mimeType.present? 
-            ##TODO, this is all done by rubydora -- remove
-            ds.mimeType = blob.respond_to?(:content_type) ? blob.content_type : "application/octet-stream"
-          end
-          if !ds.dsLabel.present? && blob.respond_to?(:path)
-            ds.dsLabel = File.basename(blob.path)
-          end
-        end
-        ds.content = blob || "" 
-      end
-      ds
-    end
-
-    module ClassMethods
-      # @param [String] dsid the datastream id
-      # @return [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
-      # by any the implementation of the datastream(specified as :type)
-      #
-      # @param [Hash] args 
-      # @option args [Class] :type The class that will represent this datastream, should extend ``Datastream''
-      # @option args [String] :name the handle to refer to this datastream as
-      # @option args [String] :label sets the fedora label
-      # @option args [String] :control_group must be one of 'E', 'X', 'M', 'R'
-      # @option args [String] :disseminator Sets the disseminator location see {#add_disseminator_location_to_datastreams}
-      # @option args [String] :url 
-      # @option args [Boolean] :autocreate Always create this datastream on new objects
-      # @option args [Boolean] :versionable Should versioned datastreams be stored
-      # @yield block executed by some kinds of datastreams
-      def has_metadata(*args, &block)
-        @metadata_ds_defaults ||= {
-          :autocreate => false,
-          :type=>nil,
-          :label=>"",
-          :control_group=>nil,
-          :disseminator=>"",
-          :url=>"",
-          :name=>nil
-        }
-        spec_datastream(args, @metadata_ds_defaults, &block)
-      end
-
-      
-      # @overload has_file_datastream(name, args)
-      #   Declares a file datastream exists for objects of this type
-      #   @param [String] name 
-      #   @param [Hash] args 
-      #     @option args :type (ActiveFedora::Datastream) The class the datastream should have
-      #     @option args :label ("File Datastream") The default value to put in the dsLabel field
-      #     @option args :control_group ("M") The type of controlGroup to store the datastream as. Defaults to M
-      #     @option args [Boolean] :autocreate Always create this datastream on new objects
-      #     @option args [Boolean] :versionable Should versioned datastreams be stored
-      # @overload has_file_datastream(args)
-      #   Declares a file datastream exists for objects of this type
-      #   @param [Hash] args 
-      #     @option args :name ("content") The dsid of the datastream
-      #     @option args :type (ActiveFedora::Datastream) The class the datastream should have
-      #     @option args :label ("File Datastream") The default value to put in the dsLabel field
-      #     @option args :control_group ("M") The type of controlGroup to store the datastream as. Defaults to M
-      #     @option args [Boolean] :autocreate Always create this datastream on new objects
-      #     @option args [Boolean] :versionable Should versioned datastreams be stored
-      def has_file_datastream(*args)
-        @file_ds_defaults ||= {
-          :autocreate => false,
-          :type=>ActiveFedora::Datastream,
-          :label=>"File Datastream",
-          :control_group=>"M",
-          :name=>"content"
-        }
-        spec_datastream(args, @file_ds_defaults)
-      end
-
-      def build_datastream_accessor(dsid)
-        name = name_for_dsid(dsid)
-        define_method name do
-          datastreams[dsid]
-        end
-        end
-
-
-      private
-
-      # Creates a datastream spec combining the given args and default values
-      # @param args [Array] either [String, Hash] or [Hash]; the latter must .has_key? :name
-      # @param defaults [Hash] the default values for the datastream spec
-      # @yield block executed by some kinds of datastreams
-      def spec_datastream(args, defaults, &block)
-        if args.first.is_a? String 
-          name = args.first
-          args = args[1] || {}
-          args[:name] = name
-        else
-          args = args.first || {}
-        end
-        spec = defaults.merge(args.select {|key, value| defaults.has_key? key})
-        name = spec.delete(:name)
-        raise ArgumentError, "You must provide a name (dsid) for the datastream" unless name
-        raise ArgumentError, "You must provide a :type property for the datastream '#{name}'" unless spec[:type]
-        spec[:versionable] = args[:versionable] if args.has_key? :versionable
-        spec[:block] = block if block
-        build_datastream_accessor(name)
-        ds_specs[name]= spec
-      end
-
-        ## Given a dsid return a standard name
-        def name_for_dsid(dsid)
-          dsid.gsub('-', '_')
-        end
-
-    end
-
   end
 end

data/lib/active_fedora/datastreams/nokogiri_datastreams.rb

@@ -5,26 +5,6 @@ module ActiveFedora
 
       module ClassMethods
 
-        # Create an instance of this class based on xml content
-        # @param [String, File, Nokogiri::XML::Node] xml the xml content to build from
-        # @param [ActiveFedora::OmDatastream] tmpl the Datastream object that you are building @default a new instance of this class
-        # Careful! If you call this from a constructor, be sure to provide something 'ie. self' as the @tmpl. Otherwise, you will get an infinite loop!
-        def from_xml(xml, tmpl=nil)
-          tmpl = self.new if tmpl.nil?  ## This path is used only for unit testing (e.g. MarpaDCDatastream.from_xml(fixture("data.xml")) )
-
-          if !xml.present?
-            tmpl.ng_xml = self.xml_template
-          elsif xml.kind_of? Nokogiri::XML::Node || xml.kind_of?(Nokogiri::XML::Document)
-            tmpl.ng_xml = xml
-          else
-            tmpl.ng_xml = Nokogiri::XML::Document.parse(xml)
-          end
-
-          tmpl.ng_xml_doesnt_change!
-
-          return tmpl
-        end
-        
         def xml_template
           Nokogiri::XML::Document.parse("<xml/>")
         end
@@ -37,11 +17,11 @@ module ActiveFedora
 
       def ng_xml 
         @ng_xml ||= begin
-          if new?
+          if new_record?
             ## Load up the template
             xml = self.class.xml_template
           else
-            xml = Nokogiri::XML::Document.parse(datastream_content)
+            xml = Nokogiri::XML::Document.parse(remote_content)
           end
           self.class.decorate_ng_xml xml
         end
@@ -49,7 +29,8 @@ module ActiveFedora
       
       def ng_xml=(new_xml)
         # before we set ng_xml, we load the datastream so we know if the new value differs.
-        local_or_remote_content(true)
+        # TODO reinstate this
+        #local_or_remote_content(true)
 
         case new_xml 
         when Nokogiri::XML::Document
@@ -64,45 +45,42 @@ module ActiveFedora
         end
       end
       
-      # don't want content eagerly loaded by proxy, so implementing methods that would be implemented by define_attribute_methods 
+      def refresh_attributes
+        changed_attributes.clear
+        @ng_xml = nil
+      end
+
+      # don't want content eagerly loaded by proxy, so implementing methods that would be implemented by define_attribute_methods
       def ng_xml_will_change!
-        attributes_changed_by_setter[:ng_xml] = nil
+        changed_attributes['ng_xml'] = nil
       end
 
       def ng_xml_doesnt_change!
-        clear_attribute_changes([:ng_xml])
+        changed_attributes.delete('ng_xml')
       end
-      
-      # don't want content eagerly loaded by proxy, so implementing methods that would be implemented by define_attribute_methods 
+
+      # don't want content eagerly loaded by proxy, so implementing methods that would be implemented by define_attribute_methods
       def ng_xml_changed?
-        changed_attributes.has_key? :ng_xml
+        changed_attributes.has_key? 'ng_xml'
       end
 
-      def datastream_content
-        @datastream_content ||= Nokogiri::XML(super).to_xml  {|config| config.no_declaration}.strip
+      def remote_content
+        @datastream_content ||= Nokogiri::XML(super).to_xml {|config| config.no_declaration}.strip
       end
-      
+
       def content=(new_content)
-        if inline?
-          # inline datastreams may be transformed by fedora 3, so we test for equivalence instead of equality
-          if !EquivalentXml.equivalent?(datastream_content, new_content)
-            ng_xml_will_change! 
-            @ng_xml = Nokogiri::XML::Document.parse(new_content)
-            super(@ng_xml.to_s)
-          end
-        else
-          if datastream_content != new_content
-            ng_xml_will_change! 
-            @ng_xml = Nokogiri::XML::Document.parse(new_content)
-            super(@ng_xml.to_s)
-          end
+        if remote_content != new_content.to_s
+          ng_xml_will_change!
+          @ng_xml = Nokogiri::XML::Document.parse(new_content)
+          super(@ng_xml.to_s.strip)
         end
         self.class.decorate_ng_xml @ng_xml
       end
 
       def content_changed?
-        return false if !xml_loaded
-        super
+        return true if autocreate? && new_record?
+        return false unless xml_loaded
+        ng_xml_changed?
       end
 
       def to_xml(xml = nil)
@@ -124,11 +102,11 @@ module ActiveFedora
               raise "You can only pass instances of Nokogiri::XML::Node into this method.  You passed in #{xml}"
           end
         end
-        
-        return xml.to_xml {|config| config.no_declaration}.strip
+
+        return xml.to_xml.strip
       end
 
-      def local_or_remote_content(ensure_fetch = true)
+      def content
         @content = to_xml if ng_xml_changed? || autocreate?
         super
       end
@@ -140,7 +118,6 @@ module ActiveFedora
       def xml_loaded
         instance_variable_defined? :@ng_xml
       end
-    
     end
   end
 end