active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/auditable.rb

@@ -1,9 +0,0 @@
-module ActiveFedora
-  module Auditable
-    
-    def audit_trail
-      inner_object.audit_trail
-    end
-
-  end
-end

data/lib/active_fedora/content_model.rb

@@ -1,70 +0,0 @@
-module ActiveFedora
-  module ContentModel
-    CMODEL_NAMESPACE = "afmodel"
-    CMODEL_PID_SUFFIX = ""
-    
-    ###Override this, if you prefer your class names serialized some other way
-    def self.sanitized_class_name(klass)
-      klass.name.gsub(/(::)/, '_')
-    end
-    
-    # list all of the models asserted by the provided object
-    def self.models_asserted_by(obj)
-      obj.relationships(:has_model)
-    end
-    
-    def self.best_model_for(obj)
-      best_model_match = nil
-
-      known_models_for(obj).each do |model_value|
-        if model_value <= obj.class
-          # If there is an inheritance structure, use the most specific case.
-          if best_model_match.nil? || best_model_match > model_value
-            best_model_match = model_value
-          end
-        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 
-    # StreamingVideo model, it will be excluded from this list.
-    def self.known_models_for(obj)
-      models_array = []
-      models_asserted_by( obj ).each do |model_uri|
-        m = uri_to_model_class(model_uri)
-        if m
-          models_array << m
-        end
-      end
-      
-      if models_array.empty?
-        models_array = [default_model(obj)]
-      end
-      
-      return models_array
-    end
-
-    ### Returns a ruby class to use if no other class could be find to instantiate
-    ### Override this method if you need something other than the default strategy
-    def self.default_model(obj)
-      ActiveFedora::Base
-    end
-    
-    
-    # Returns an ActiveFedora Model class corresponding to the given uri if one can be found.
-    # Returns false if no corresponding model can be found.
-    def self.uri_to_model_class( uri )
-      rc = Model.from_class_uri(uri)
-      if rc && (rc.superclass == ActiveFedora::Base || rc.ancestors.include?(ActiveFedora::Base))
-        rc
-      else
-        false
-      end
-    end
-    
-  end
-end

data/lib/active_fedora/datastream_collections.rb

@@ -1,302 +0,0 @@
-require 'active_support/core_ext/module/aliasing'
-module ActiveFedora
-  module DatastreamCollections
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :class_named_datastreams_desc
-      self.class_named_datastreams_desc = {}
-    end
-
-    module ClassMethods
-      def inherited(kls) #:nodoc:
-        super
-        kls.class_named_datastreams_desc = kls.class_named_datastreams_desc.dup
-      end
-
-      # Allows for a datastream to be treated like any other attribute of a model class 
-      # while enforcing mimeType and/or datastream type (ie. external, managed, etc.) if defined. 
-      # ====Examples 
-      #                 
-      #  has_datastream :name=>"thumbnails",:prefix => "THUMB",:type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'                     
-      #  has_datastream :name=>"EADs", :type=>ActiveFedora::Datastream, :mimeType=>"application/xml", :controlGroup=>'M' 
-      #  has_datastream :name=>"external_images", :type=>ActiveFedora::Datastream, :controlGroup=>'E' 
-      #
-      # Required Keys in args
-      #  :name  -  name to give this datastream (must be unique)
-      #
-      # Optional Keys in args
-      #  :prefix - used to create the DSID plus an index ie. THUMB1, THUMB2.  If :prefix is not specified, defaults to :name value in all uppercase 
-      #  :type - defaults to ActiveFedora::Datastream if you would like content specific class to be used supply it here
-      #  :mimeType - if supplied it will ensure any datastreams added are of this type, if not supplied any mimeType is acceptabl e
-      #  :controlGroup -  possible values "X", "M", "R", or "E" (InlineXML, Managed Content, Redirect, or External Referenced) If controlGroup is 'E' or 'R' it expects a dsLocation be defined when adding the datastream.
-      #
-      # You use the datastream attribute using helper methods created for each datastream name:
-      #
-      # ====Helper Method Examples
-      #  thumbnails_append -  Append a thumbnail datastream
-      #  thumbnails        -  Get array of thumbnail datastreams
-      #  thumbnails_ids    -  Get array of dsid's for thumbnail datastreams
-      #
-      # When loading the list of datastreams for a name from Fedora it uses the DSID prefix to find them in Fedora
-      def has_datastream(args)
-        unless args.has_key?(:name)
-          return false
-        end
-        unless args.has_key?(:prefix)
-          args.merge!({:prefix=>args[:name].to_s.upcase})
-        end
-        unless class_named_datastreams_desc.has_key?(args[:name]) 
-          class_named_datastreams_desc[args[:name]] = {} 
-        end
-            
-        args.merge!({:mimeType=>args[:mime_type]}) if args.has_key?(:mime_type)
-        
-        unless args.has_key?(:type) 
-          #default to type ActiveFedora::Datastream
-          args[:type] = "ActiveFedora::Datastream"
-        else
-          # stringify class/model names
-          args[:type] = args[:type].name if args[:type].is_a? Class
-        end
-        class_named_datastreams_desc[args[:name]]= args   
-        create_named_datastream_finders(args[:name],args[:prefix])
-        create_named_datastream_update_methods(args[:name])
-      end
-      
-      # Creates the following helper methods for a datastream name
-      #   [datastream_name]_append  - Add a named datastream
-      #
-      # ==== Examples for "thumbnails" datastream
-      #  thumbnails_append -  Append a thumbnail datastream
-      # TODO: Add [datastream_name]_remove
-      def create_named_datastream_update_methods(name)
-        append_file_method_name = "#{name.to_s.downcase}_file_append"
-        append_method_name = "#{name.to_s.downcase}_append"
-        #remove_method_name = "#{name.to_s.downcase}_remove"
-        self.send(:define_method,:"#{append_file_method_name}") do |*args| 
-          file,opts = *args
-          opts ||= {}
-          add_named_file_datastream(name,file,opts)
-        end
-        
-        self.send(:define_method,:"#{append_method_name}") do |*args| 
-          #call add_named_datastream instead of add_file_named_datastream in case not managed datastream
-          add_named_datastream(name,*args)
-        end
-      end 
-      
-      # Creates the following helper methods for a datastream name
-      #   [datastream_name]  - Returns array of named datastreams
-      #   [datastream_name]_ids - Returns array of named datastream dsids
-      #
-      # ==== Examples for "thumbnails" datastream
-      #  thumbnails        -  Get array of thumbnail datastreams
-      #  thumbnails_ids    -  Get array of dsid's for thumbnail datastreams
-      def create_named_datastream_finders(name, prefix)
-        class_eval <<-END,  __FILE__, __LINE__
-        def #{name}(opts={})
-          id_array = []
-          keys = datastreams.keys
-
-          id_array = keys.select {|v| v =~ /^#{prefix}\\d+$/}
-
-          if opts[:response_format] == :id_array
-            return id_array
-          else
-            named_ds = []
-            id_array.each do |name|
-              if datastreams.has_key?(name)
-                named_ds.push(datastreams[name])
-              end
-            end
-            return named_ds
-          end
-        end
-        def #{name}_ids
-          #{name}(:response_format => :id_array)
-        end
-        END
-      end
-      
-
-
-    end
-
-      # Accessor for class variable for hash that stores arguments passed to has_datastream calls within an
-      # ActiveFedora::Base child class.    
-      #  
-      #  has_datastream :name=>"audio_file", :prefix=>"AUDIO", :type=>ActiveFedora::Datastream, :mimeType=>"audio/x-wav" 
-      #  has_datastream :name=>"external_images", :prefix=>"EXTIMG", :type=>ActiveFedora::Datastream,:mimeType=>"image/jpeg", :controlGroup=>'E'
-      #
-      # The above examples result in the following hash
-      #  {"audio_file"=>{:prefix=>"AUDIO",:type=>ActiveFedora::Datastream, :mimeType=>"audio/x-wav", :controlGroup=>'M'},
-      #   "external_images=>{:prefix=>"EXTIMG", :type=>ActiveFedora::Datastream,:mimeType=>"image/jpeg", :controlGroup=>'E'}}
-      #
-      # This hash is later used when adding a named datastream such as an "audio_file" as defined above.
-      def named_datastreams_desc
-        self.class_named_datastreams_desc ||= {}
-      end
-
-      # Returns array of datastream names defined for this object 
-      def datastream_names
-        named_datastreams_desc.keys
-      end
-      
-      # Calls add_named_datastream while assuming it will be managed content and sets :blob and :controlGroup values accordingly
-      # ====Parameters
-      #  name: Datastream name
-      #  file: The file to add for this datastream
-      #  opts: Options hash.  See +add_named_datastream+ for expected keys and values
-      def add_named_file_datastream(name, file, opts={})
-        opts.merge!({:blob=>file,:controlGroup=>'M'})
-        add_named_datastream(name,opts)
-      end
-      
-      # This object is used by [datastream_name]_append helper to add a named datastream
-      # but can also be called directly.
-      # ====Parameters
-      #  name: name of datastream to add
-      #  opts: hash defining datastream attributes
-      # The following are expected keys in opts hash:
-      #   :label => Defaults to the file name
-      #   :blob or :file  => Required to point to the datastream file being added if managed content
-      #   :controlGroup => defaults to 'M' for managed, can also be 'E' external and 'R' for redirected
-      #   :content_type => required if the file does not respond to 'content_type' and should match :mimeType in has_datastream definition if defined
-      #   :dsLocation => holds uri location of datastream.  Required only if :controlGroup is type 'E' or 'R'.
-      #   :dsid or :dsId => Optional, and used to update an existing datastream with dsid supplied.  Will throw an error if dsid does not exist and does not match prefix pattern for datastream name
-      def add_named_datastream(name,opts={})
-        unless named_datastreams_desc.has_key?(name) && named_datastreams_desc[name].has_key?(:type) 
-          raise "Failed to add datastream. Named datastream #{name} not defined for object #{pid}." 
-        end
-
-        if opts.has_key?(:mime_type)
-          opts.merge!({:content_type=>opts[:mime_type]})
-        elsif opts.has_key?(:mimeType)
-          opts.merge!({:content_type=>opts[:mimeType]})
-        end
-        opts.merge!(named_datastreams_desc[name])
-          
-        label = opts.has_key?(:label) ? opts[:label] : ""
-
-        #only do these steps for managed datastreams
-        unless (opts.has_key?(:controlGroup)&&opts[:controlGroup]!="M")
-          if opts.has_key?(:file)
-            opts.merge!({:blob => opts[:file]}) 
-            opts.delete(:file)
-          end
-          
-          raise "You must define parameter blob for this managed datastream to load for #{pid}" unless opts.has_key?(:blob)
-          
-          #if no explicit label and is a file use original file name for label
-          if !opts.has_key?(:label)&&opts[:blob].respond_to?(:original_filename)
-            label = opts[:blob].original_filename
-          end
-          
-          if opts[:blob].respond_to?(:content_type)&&!opts[:blob].content_type.nil? && !opts.has_key?(:content_type)
-            opts.merge!({:content_type=>opts[:blob].content_type})
-          end
-
-          raise "The blob must respond to content_type or the hash must have :content_type or :mime_type property set" unless opts.has_key?(:content_type)
-          
-          #throw error for mimeType mismatch
-          if named_datastreams_desc[name].has_key?(:mimeType) && !named_datastreams_desc[name][:mimeType].eql?(opts[:content_type])
-            raise "Content type mismatch for add datastream #{name} to #{pid}.  Expected: #{named_datastreams_desc[name][:mimeType]}, Actual: #{opts[:content_type]}"
-          end
-        else 
-          label = opts[:dsLocation] if (opts.has_key?(:dsLocation)) 
-        end
-        
-        opts.merge!(:dsLabel => label)
-        
-        ds = create_datastream(named_datastreams_desc[name][:type], opts[:dsid], opts)
-        #Must be of type datastream
-        assert_kind_of 'datastream',  ds, ActiveFedora::Datastream
-        #make sure dsid is nil so that it uses the prefix for mapping purposes
-        #check dsid works for the prefix if it is set
-        if ds.dsid && opts.has_key?(:prefix)
-          raise "dsid supplied (#{ds.dsid}) does not conform to pattern #{opts[:prefix]}[number]" unless ds.dsid =~ /#{opts[:prefix]}[0-9]/
-        end
-        
-        add_datastream(ds,opts)
-      end
-
-      # Update an existing named datastream.  It has same parameters as add_named_datastream
-      # except the :dsid key is now required.
-      #
-      # ====TODO
-      # Currently requires you to update file if a managed datastream 
-      # but could change to allow metadata only updates as well
-      def update_named_datastream(name, opts={})
-        #check that dsid provided matches existing datastream with that name
-        raise "You must define parameter dsid for datastream to update for #{pid}" unless opts.include?(:dsid)
-        raise "Datastream with name #{name} and dsid #{opts[:dsid]} does not exist for #{pid}" unless self.send("#{name}_ids").include?(opts[:dsid])
-        add_named_datastream(name,opts)
-      end
-      
-      # Throws an assertion failure unless the object 'o' is kind_of? class 't'
-      # ====Parameters
-      #  n: Name of object
-      #  o: The object to test
-      #  t: The class type to check is kind_of?
-      def assert_kind_of(n,o,t)
-        raise "Assertion failure: #{n}: #{o} is not of type #{t}" unless o.kind_of?(t)
-      end
-      
-      # Returns true if the name is a defined named datastream
-      def is_named_datastream?(name)
-        named_datastreams_desc.has_key?(name)
-      end
-
-      # Returns hash of datastream names defined by has_datastream calls mapped to 
-      # array of datastream objects that have been added
-      # ====Example
-      # For the following has_datastream entries and a datastream defined for minivan only would be
-      #  has_datastream :name=>"minivan", :prefix => "VAN", :type=>ActiveFedora::Datastream,:mimeType=>"image/jpeg", :controlGroup=>'M'
-      #  has_datastream :name=>"external_images", :prefix=>"EXTIMG", :type=>ActiveFedora::Datastream,:mimeType=>"image/jpeg", :controlGroup=>'E'
-      #
-      # Returns
-      #  {"external_images"=>[],"thumbnails"=>{#<ActiveFedora::Datastream:0x7ffd6512daf8 ...}} 
-      def named_datastreams
-        ds_values = {}
-        self.class.class_named_datastreams_desc.keys.each do |name|
-          ds_values.merge!({name=>self.send("#{name}")})
-        end
-        return ds_values
-      end
-      
-      # Returns hash of datastream names mapped to an array
-      # of dsid's for named datastream objects
-      # === Example
-      # For the following has_datastream call, assume we have added two datastreams.
-      # 
-      #  has_datastream :name=>"thumbnails",:prefix => "THUMB",:type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'                     
-      #
-      # It would then return
-      #  {"thumbnails=>["THUMB1", "THUMB2"]}
-      def named_datastreams_ids
-        dsids = {}
-        self.class.class_named_datastreams_desc.keys.each do |name|
-          dsid_array = self.send("#{name}_ids")
-          dsids[name] = dsid_array
-        end
-        return dsids
-      end 
-      
-      # Returns the hash that stores arguments passed to has_datastream calls within an
-      # ActiveFedora::Base child class.    
-      #  
-      #  has_datastream :name=>"audio_file", :prefix=>"AUDIO", :type=>ActiveFedora::Datastream, :mimeType=>"audio/x-wav" 
-      #  has_datastream :name=>"external_images", :prefix=>"EXTIMG", :type=>ActiveFedora::Datastream,:mimeType=>"image/jpeg", :controlGroup=>'E'
-      #
-      # The above examples result in the following hash
-      #  {"audio_file"=>{:prefix=>"AUDIO",:type=>ActiveFedora::Datastream, :mimeType=>"audio/x-wav", :controlGroup=>'M'},
-      #   "external_images=>{:prefix=>"EXTIMG", :type=>ActiveFedora::Datastream,:mimeType=>"image/jpeg", :controlGroup=>'E'}}
-      #
-      # This hash is later used when adding a named datastream such as an "audio_file" as defined above.
-      def named_datastreams_desc
-        @named_datastreams_desc ||= self.class.class_named_datastreams_desc
-      end
-      
-  end
-end

data/lib/active_fedora/datastream_hash.rb

@@ -1,35 +0,0 @@
-require 'forwardable'
-
-module ActiveFedora
-  class DatastreamHash
-    extend Forwardable
-
-    def_delegators :@hash, *(Hash.instance_methods(false))
-    
-    def initialize (obj, &block)
-      @obj = obj
-      @hash = Hash.new &block
-    end
-
-    def [] (key)
-      if key == 'DC' && !has_key?(key)
-        ds = Datastream.new(@obj.inner_object, key, :controlGroup=>'X')
-        self[key] = ds
-      end
-      @hash[key]
-    end 
-
-    def []= (key, val)
-      @obj.inner_object.datastreams[key]=val
-      @hash[key]=val
-    end
-
-    def freeze
-      each_value do |datastream|
-        datastream.freeze
-      end
-      @hash.freeze
-      super
-    end
-  end
-end

data/lib/active_fedora/digital_object.rb

@@ -1,55 +0,0 @@
-module ActiveFedora
-  # Helps Rubydora create datastreams of the type defined by the ActiveFedora::Base#datastream_class_for_name
-  class DigitalObject < Rubydora::DigitalObject
-    attr_accessor :original_class
-    
-    module DatastreamBootstrap
-      def datastream_object_for dsid, options={}, 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)
-        attributes = {}
-        attributes[:asOfDateTime] ||= asOfDateTime if self.respond_to? :asOfDateTime
-        attributes[:dsLabel] = ds_spec[:label] if ds_spec[:label].present?
-        attributes[:controlGroup] = ds_spec[:control_group] if ds_spec[:control_group].present?
-        attributes[:versionable] = ds_spec[:versionable] unless ds_spec[:versionable].nil?
-        if attributes[:controlGroup]=='E'
-          if !ds_spec[:disseminator].present? && ds_spec[:url].present?
-            attributes[:dsLocation]= ds_spec[:url]
-          end
-        elsif attributes[:controlGroup]=='R'
-          attributes[:dsLocation]= ds_spec[:url]
-        end
-        ds.default_attributes = attributes
-        # would rather not load profile here in the call to .new?, so trusting :autocreate attribute
-        if ds_spec[:autocreate] # and ds.new?
-          ds.datastream_will_change!
-        end
-        ds
-      end
-    end    
-    include DatastreamBootstrap
-
-    def self.find(original_class, pid)
-      raise ActiveFedora::ObjectNotFoundError.new("Unable to find #{pid.inspect} in fedora. ") unless pid.present?
-      conn = original_class.connection_for_pid(pid)
-      obj = begin
-        super(pid, conn)
-      rescue Rubydora::RecordNotFound
-        raise ActiveFedora::ObjectNotFoundError, "Unable to find '#{pid}' in fedora. See logger for details."
-      end
-      obj.original_class = original_class
-      # PID is not found, but was "well-formed" for its Fedora request. So
-      # an object is instantiated with that PID.
-      raise ActiveFedora::ObjectNotFoundError, "Unable to find '#{pid}' in fedora" if obj.new?
-      obj
-    end
-
-    def self.find_or_initialize(original_class, pid)
-      conn = original_class.connection_for_pid(pid)
-      obj = super(pid, conn)
-      obj.original_class = original_class
-      obj
-    end
-  end
-end