active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/file_configurator.rb

@@ -7,37 +7,37 @@ module ActiveFedora
     # Initializes ActiveFedora's connection to Fedora and Solr based on the info in fedora.yml and solr.yml
     # NOTE: this deprecates the use of a solr url in the fedora.yml
     #
-    # 
+    #
     # If Rails.env is set, it will use that environment.  Defaults to "development".
     # @param [Hash] options (optional) a list of options for the configuration of active_fedora
     # @option options [String] :environment The environment within which to run
     # @option options [String] :fedora_config_path The full path to the fedora.yml config file.
     # @option options [String] :solr_config_path The full path to the solr.yml config file.
-    # 
-    # If :environment is not set, order of preference is 
+    #
+    # If :environment is not set, order of preference is
     # 1. Rails.env
     # 2. ENV['environment']
     # 3. RAILS_ENV
     #
-    # If :fedora_config_path is not set, it will look in 
+    # If :fedora_config_path is not set, it will look in
     # 1. +Rails.root+/config
     # 2. +current working directory+/config
     # 3. (default) the fedora.yml shipped with gem
     #
-    # If :solr_config_path is not set, it will 
+    # If :solr_config_path is not set, it will
     # 1. look in config_options[:fedora_config_path].  If it finds a solr.yml there, it will use it.
-    # 2. If it does not find a solr.yml and the fedora.yml contains a solr url, it will raise an configuration error 
+    # 2. If it does not find a solr.yml and the fedora.yml contains a solr url, it will raise an configuration error
     # 3. If it does not find a solr.yml and the fedora.yml does not contain a solr url, it will look in: +Rails.root+/config, +current working directory+/config, then the solr.yml shipped with gem
 
     # Options allowed in fedora.yml
-    # first level is the environment (e.g. development, test, production and any custom environments you may have) 
+    # first level is the environment (e.g. development, test, production and any custom environments you may have)
     # the second level has these keys:
     # 1. url: url including protocol, host, port and path (e.g. http://127.0.0.1:8983/fedora)
     # 2. user: username
     # 3. password: password
-    # 4. validateChecksum:  indicates to the fedora server whether you want to validate checksums when the datastreams are queried.  
+    # 4. validateChecksum:  indicates to the fedora server whether you want to validate checksums when the datastreams are queried.
     #
-    # @example If you want to shard the fedora instance, you can specify an array of credentials. 
+    # @example If you want to shard the fedora instance, you can specify an array of credentials.
     #   production:
     #   - user: user1
     #     password: password1
@@ -56,7 +56,7 @@ module ActiveFedora
     end
 
     def init options = {}
-      if options.is_a?(String) 
+      if options.is_a?(String)
         raise ArgumentError, "Calling ActiveFedora.init with a path as an argument has been removed.  Use ActiveFedora.init(:fedora_config_path=>#{options})"
       end
       reset!
@@ -76,7 +76,7 @@ module ActiveFedora
     def path
       get_config_path(:fedora)
     end
-    
+
     def reset!
       @config_loaded = false  #Force reload of configs
       @fedora_config = {}
@@ -92,7 +92,7 @@ module ActiveFedora
     def load_configs
       return if config_loaded?
       @config_env = ActiveFedora.environment
-      
+
       load_fedora_config
       load_solr_config
       @config_loaded = true
@@ -101,7 +101,7 @@ module ActiveFedora
     def load_fedora_config
       return @fedora_config unless @fedora_config.empty?
       @fedora_config_path = get_config_path(:fedora)
-      ActiveFedora::Base.logger.info("ActiveFedora: loading fedora config from #{File.expand_path(@fedora_config_path)}") if ActiveFedora::Base.logger
+      ActiveFedora::Base.logger.info("ActiveFedora: loading fedora config from #{::File.expand_path(@fedora_config_path)}") if ActiveFedora::Base.logger
 
       begin
         config_erb = ERB.new(IO.read(@fedora_config_path)).result(binding)
@@ -126,7 +126,7 @@ module ActiveFedora
       return @solr_config unless @solr_config.empty?
       @solr_config_path = get_config_path(:solr)
 
-      ActiveFedora::Base.logger.info "ActiveFedora: loading solr config from #{File.expand_path(@solr_config_path)}" if ActiveFedora::Base.logger
+      ActiveFedora::Base.logger.info "ActiveFedora: loading solr config from #{::File.expand_path(@solr_config_path)}" if ActiveFedora::Base.logger
       begin
         config_erb = ERB.new(IO.read(@solr_config_path)).result(binding)
       rescue Exception => e
@@ -144,7 +144,7 @@ module ActiveFedora
       @solr_config = {:url=> get_solr_url(config[ActiveFedora.environment.to_sym].symbolize_keys)}
     end
 
-    # Given the solr_config that's been loaded for this environment, 
+    # Given the solr_config that's been loaded for this environment,
     # determine which solr url to use
     def get_solr_url(solr_config)
       if @index_full_text == true && solr_config.has_key?(:fulltext) && solr_config[:fulltext].has_key?('url')
@@ -159,7 +159,7 @@ module ActiveFedora
         raise URI::InvalidURIError
       end
     end
-      
+
     # Determine the fedora config file to use. Order of preference is:
     # 1. Use the config_options[:config_path] if it exists
     # 2. Look in +Rails.root+/config/fedora.yml
@@ -170,10 +170,10 @@ module ActiveFedora
     def get_config_path(config_type)
       config_type = config_type.to_s
       if (config_path = config_options.fetch("#{config_type}_config_path".to_sym,nil) )
-        raise ConfigurationError, "file does not exist #{config_path}" unless File.file? config_path
-        return File.expand_path(config_path)
+        raise ConfigurationError, "file does not exist #{config_path}" unless ::File.file? config_path
+        return ::File.expand_path(config_path)
       end
-    
+
       # if solr, attempt to use path where fedora.yml is first
       if config_type == "solr" && (config_path = check_fedora_path_for_solr)
         return config_path
@@ -181,27 +181,27 @@ module ActiveFedora
 
       if defined?(Rails.root)
         config_path = "#{Rails.root}/config/#{config_type}.yml"
-        return config_path if File.file? config_path
+        return config_path if ::File.file? config_path
       end
-    
-      if File.file? "#{Dir.getwd}/config/#{config_type}.yml"  
+
+      if ::File.file? "#{Dir.getwd}/config/#{config_type}.yml"
         return "#{Dir.getwd}/config/#{config_type}.yml"
       end
-    
+
       # Last choice, check for the default config file
-      config_path = File.join(ActiveFedora.root, "config", "#{config_type}.yml")
-      if File.file? config_path
+      config_path = ::File.join(ActiveFedora.root, "config", "#{config_type}.yml")
+      if ::File.file? config_path
         ActiveFedora::Base.logger.warn "Using the default #{config_type}.yml that comes with active-fedora.  If you want to override this, pass the path to #{config_type}.yml to ActiveFedora - ie. ActiveFedora.init(:#{config_type}_config_path => '/path/to/#{config_type}.yml') - or set Rails.root and put #{config_type}.yml into \#{Rails.root}/config." if ActiveFedora::Base.logger
         return config_path
       else
         raise ConfigurationError, "Couldn't load #{config_type} config file!"
       end
     end
-  
+
     # Checks the existing fedora_config.path to see if there is a solr.yml there
     def check_fedora_path_for_solr
-      path = File.dirname(self.path) + "/solr.yml"
-      if File.file? path
+      path = ::File.dirname(self.path) + "/solr.yml"
+      if ::File.file? path
         return path
       else
         return nil
@@ -210,21 +210,21 @@ module ActiveFedora
 
     def predicate_config
       @predicate_config_path ||= build_predicate_config_path
-      YAML.load(File.open(@predicate_config_path)) if File.exist?(@predicate_config_path)
+      YAML.load(::File.open(@predicate_config_path)) if ::File.exist?(@predicate_config_path)
     end
 
     protected
 
     def build_predicate_config_path
-      testfile = File.expand_path(get_config_path(:predicate_mappings))
-      if File.exist?(testfile) && valid_predicate_mapping?(testfile)
+      testfile = ::File.expand_path(get_config_path(:predicate_mappings))
+      if ::File.exist?(testfile) && valid_predicate_mapping?(testfile)
         return testfile
       end
       raise PredicateMappingsNotFoundError
     end
 
     def valid_predicate_mapping?(testfile)
-      mapping = YAML.load(File.open(testfile))
+      mapping = YAML.load(::File.open(testfile))
       return false unless mapping.has_key?(:default_namespace) && mapping[:default_namespace].is_a?(String)
       return false unless mapping.has_key?(:predicate_mapping) && mapping[:predicate_mapping].is_a?(Hash)
       true

data/lib/active_fedora/file_path_builder.rb

@@ -0,0 +1,24 @@
+module ActiveFedora
+  class FilePathBuilder
+    # Builds a relative path for a file
+    def self.build(digital_object, name, prefix)
+      name = nil if name == ''
+      prefix ||= 'DS'
+      name || generate_dsid(digital_object, prefix)
+    end
+
+    # 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 self.generate_dsid(digital_object, prefix)
+      return unless digital_object
+      matches = digital_object.attached_files.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 ids are formatted (e.g DS01 instead of DS1)
+    def self.format_dsid(prefix, suffix)
+      sprintf("%s%i", prefix,suffix)
+    end
+  end
+end

data/lib/active_fedora/files_hash.rb

@@ -0,0 +1,82 @@
+require 'forwardable'
+
+module ActiveFedora
+  class FilesHash
+    extend Forwardable
+
+    def initialize (model)
+      @base = model
+    end
+
+    def [] (name)
+      association(name).reader if association(name)
+    end
+
+    def []= (name, object)
+      association(name).writer(object) if association(name)
+    end
+
+    def association(name)
+      # Check to see if the key exists before casting to a symbol, because symbols
+      # are not garbage collected in earlier versions of Ruby
+      @base.association(name.to_sym) if key?(name)
+    end
+
+    def reflections
+      @base.class.child_resource_reflections
+    end
+
+    def each
+      keys.each do |k|
+        yield k, self[k]
+      end
+    end
+
+    def keys
+      reflections.keys + @base.undeclared_files
+    end
+
+    # Check that the key exists with indifferent access (symbol or string) in a
+    # manner that avoids generating extra symbols. Symbols are not garbage collected
+    # in earlier versions of ruby.
+    def key?(key)
+      keys.include?(key) || keys.map(&:to_s).include?(key)
+    end
+
+    def values
+      keys.map { |k| self[k] }
+    end
+
+    def has_key?(key)
+      keys.include?(key)
+    end
+
+    def size
+      keys.size
+    end
+
+    def empty?
+      reflections.empty?
+    end
+
+    def each_value
+      keys.each do |k|
+        yield self[k]
+      end
+    end
+
+    def select
+      keys.each_with_object({}) do |k, h|
+        val = self[k]
+        h[k] = val if yield k, val
+      end
+    end
+
+    def freeze
+      keys.each do |name|
+        association(name).reader.freeze if association(name).loaded?
+      end
+      super
+    end
+  end
+end

data/lib/active_fedora/fixity_service.rb

@@ -0,0 +1,40 @@
+module ActiveFedora
+  class FixityService
+    extend ActiveSupport::Concern
+
+    attr_accessor :target, :response
+
+    # Accepts an Fedora resource such as File.ldp_resource.subject
+    def initialize target
+      raise ArgumentError, 'You must provide a uri' unless target
+      @target = target
+    end
+
+    # Executes a fixity check on Fedora and saves the Faraday::Response.
+    # Returns true when the fixity check was successfully.
+    def check
+      @response = get_fixity_response_from_fedora
+      status.match("SUCCESS") ? true : false
+    end
+
+    def status
+      fixity_graph.query(predicate: status_url).map(&:object).first.to_s
+    end
+
+    private
+
+    def get_fixity_response_from_fedora
+      uri = target + "/fcr:fixity"
+      ActiveFedora.fedora.connection.get(uri)
+    end
+
+    def fixity_graph
+      ::RDF::Graph.new << ::RDF::Reader.for(:ttl).new(response.body)
+    end
+
+    def status_url
+      ::RDF::URI("http://fedora.info/definitions/v4/repository#status")
+    end
+
+  end
+end

data/lib/active_fedora/indexing.rb

@@ -2,119 +2,92 @@ module ActiveFedora
   module Indexing
     extend ActiveSupport::Concern
 
-    included do
-      class_attribute :profile_solr_name
-      self.profile_solr_name = ActiveFedora::SolrService.solr_name("object_profile", :displayable)
-    end
-
     # Return a Hash representation of this object where keys in the hash are appropriate Solr field names.
     # @param [Hash] solr_doc (optional) Hash to insert the fields into
     # @param [Hash] opts (optional)
     # If opts[:model_only] == true, the base object metadata and the RELS-EXT datastream will be omitted.  This is mainly to support shelver, which calls .to_solr for each model an object subscribes to.
     def to_solr(solr_doc = Hash.new, opts={})
-      unless opts[:model_only]
-        c_time = create_date
-        c_time = Time.parse(c_time) unless c_time.is_a?(Time)
-        m_time = modified_date
-        m_time = Time.parse(m_time) unless m_time.is_a?(Time)
-        Solrizer.set_field(solr_doc, 'system_create', c_time, :stored_sortable)
-        Solrizer.set_field(solr_doc, 'system_modified', m_time, :stored_sortable)
-        Solrizer.set_field(solr_doc, 'object_state', state, :stored_sortable)
-        Solrizer.set_field(solr_doc, 'active_fedora_model', has_model, :stored_sortable)
-        solr_doc.merge!(SOLR_DOCUMENT_ID.to_sym => pid)
-        solrize_profile(solr_doc)
-      end
-      datastreams.each_value do |ds|
-        solr_doc.merge! ds.to_solr()
-      end
-      solr_doc = solrize_relationships(solr_doc) unless opts[:model_only]
-      solr_doc
+      indexing_service.generate_solr_document
     end
 
-    def solr_name(*args)
-      ActiveFedora::SolrService.solr_name(*args)
+    def indexing_service
+      @indexing_service ||= self.class.indexer.new(self)
     end
 
-    def solrize_profile(solr_doc = Hash.new) # :nodoc:
-      profile_hash = { 'datastreams' => {} }
-      if inner_object.respond_to? :profile
-        inner_object.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
-      end
-      self.datastreams.each_pair { |dsid,ds| profile_hash['datastreams'][dsid] = ds.solrize_profile }
-      solr_doc[self.class.profile_solr_name] = profile_hash.to_json
+    # Updates Solr index with self.
+    def update_index
+      SolrService.add(to_solr, softCommit: true)
     end
 
-    # Serialize the datastream's RDF relationships to solr
-    # @param [Hash] solr_doc @deafult an empty Hash
-    def solrize_relationships(solr_doc = Hash.new)
-      relationships.each_statement do |statement|
-        predicate = Predicates.short_predicate(statement.predicate)
-        literal = statement.object.kind_of?(::RDF::Literal)
-        val = literal ? statement.object.value : statement.object.to_str
-        ::Solrizer::Extractor.insert_solr_field_value(solr_doc, solr_name(predicate, :symbol), val )
+    protected
+
+      # Determines whether a create operation causes a solr index of this object by default.
+      # Override this if you need different behavior.
+      def create_needs_index?
+        ENABLE_SOLR_UPDATES
       end
-      return solr_doc
-    end
 
-    # Updates Solr index with self.
-    def update_index
-      if defined?( Solrizer::Fedora::Solrizer )
-        #logger.info("Trying to solrize pid: #{pid}")
-        solrizer = Solrizer::Fedora::Solrizer.new
-        solrizer.solrize( self )
-      else
-        SolrService.add(self.to_solr, softCommit: true)
+      # Determines whether an update operation causes a solr index of this object by default.
+      # Override this if you need different behavior
+      def update_needs_index?
+        ENABLE_SOLR_UPDATES
       end
-    end
 
-    # Override this method if you want to represent the class in a different way
-    def has_model
-      self.class.inspect
-    end
+    private
+
+      # index the record after it has been persisted to Fedora
+      def create_record(options = {})
+        super
+        update_index if create_needs_index? && options.fetch(:update_index, true)
+        true
+      end
+
+      # index the record after it has been updated in Fedora
+      def update_record(options = {})
+        super
+        update_index if update_needs_index? && options.fetch(:update_index, true)
+        true
+      end
 
     module ClassMethods
+
+      def indexer
+        IndexingService
+      end
+
+      def reindex_everything
+        get_descendent_uris(ActiveFedora::Base.id_to_uri('')).each do |uri|
+          logger.debug "Re-index everything ... #{uri}"
+          ActiveFedora::Base.find(LdpResource.new(ActiveFedora.fedora.connection, uri)).update_index
+        end
+      end
+
       # This method can be used instead of ActiveFedora::Model::ClassMethods.find.
       # It works similarly except it populates an object from Solr instead of Fedora.
       # It is most useful for objects used in read-only displays in order to speed up loading time.  If only
-      # a pid is passed in it will query solr for a corresponding solr document and then use it
+      # a id is passed in it will query solr for a corresponding solr document and then use it
       # to populate this object.
       #
       # If a value is passed in for optional parameter solr_doc it will not query solr again and just use the
       # one passed to populate the object.
       #
-      # It will anything stored within solr such as metadata and relationships.  Non-metadata datastreams will not
+      # It will anything stored within solr such as metadata and relationships.  Non-metadata attached files will not
       # be loaded and if needed you should use find instead.
-      def load_instance_from_solr(pid,solr_doc=nil)
-        SolrInstanceLoader.new(self, pid, solr_doc).object
+      def load_instance_from_solr(id, solr_doc=nil)
+        SolrInstanceLoader.new(self, id, solr_doc).object
       end
 
-      # Using the fedora search (not solr), get every object and reindex it.
-      # @param [String] query a string that conforms to the query param format
-      #   of the underlying search's API
-      def reindex_everything(query = nil)
-        connections.each do |conn|
-          conn.search(query) do |object|
-            next if object.pid.start_with?('fedora-system:')
-            ActiveFedora::Base.find(object.pid).update_index
-          end
+      def get_descendent_uris(uri)
+        resource = Ldp::Resource::RdfSource.new(ActiveFedora.fedora.connection, uri)
+        immediate_descendent_uris = resource.graph.query(predicate: ::RDF::LDP.contains).map { |descendent| descendent.object.to_s }
+        all_descendents_uris = [uri]
+        immediate_descendent_uris.each do |descendent_uri|
+          all_descendents_uris += get_descendent_uris(descendent_uri)
         end
+        all_descendents_uris
       end
 
-      private
-
-      def connections
-        if ActiveFedora.config.sharded?
-          return ActiveFedora.config.credentials.map { |cred| ActiveFedora::RubydoraConnection.new(cred).connection}
-        else
-          return [ActiveFedora::RubydoraConnection.new(ActiveFedora.config.credentials).connection]
-        end
-      end
     end
+
   end
 end