module Ddr::Utils

Constants

DEFAULT_MIME_TYPE

Public Class Methods

digest(content, algorithm) click to toggle source
# File lib/ddr/utils.rb, line 8
def self.digest(content, algorithm)
  raise TypeError, "Algorithm must be a string: #{algorithm.inspect}" unless algorithm.is_a?(String)
  digest_class = OpenSSL::Digest.const_get(algorithm.sub("-", "").to_sym)
  digest_class.new(content).to_s
rescue NameError => e
  raise ArgumentError, "Invalid algorithm: #{algorithm}"
end
ds_as_of_date_time(ds) click to toggle source
# File lib/ddr/utils.rb, line 80
def self.ds_as_of_date_time(ds)
  ds.create_date_string
end
file_name_for(file) click to toggle source
# File lib/ddr/utils.rb, line 47
def self.file_name_for(file)
  return file.original_filename if file.respond_to?(:original_filename) && file.original_filename.present?
  File.basename(file_path(file)) rescue nil
end
file_or_path?(file) click to toggle source
# File lib/ddr/utils.rb, line 26
def self.file_or_path?(file)
  file_path(file)
rescue ArgumentError
  false
end
file_path(file) click to toggle source
# File lib/ddr/utils.rb, line 37
def self.file_path(file)
  if file.respond_to?(:path)
    File.absolute_path(file.path)
  elsif file_path?(file)
    file
  else
    raise ArgumentError, "File argument is neither a File nor a path to an existing file."
  end
end
file_path?(file) click to toggle source
# File lib/ddr/utils.rb, line 32
def self.file_path?(file)
  # length is a sanity check
  file.is_a?(String) && (file.length < 1024) && File.exists?(file)
end
file_uri?(uri) click to toggle source
# File lib/ddr/utils.rb, line 52
def self.file_uri?(uri)
  return false unless uri
  URI.parse(uri).scheme == "file"
end
mime_type_for(file, file_name=nil) click to toggle source

Return a mime type for the file, using the file_name if necessary file can be a File object or file path (String) Return default mime type if unable to determine otherwise

# File lib/ddr/utils.rb, line 19
def self.mime_type_for(file, file_name=nil)
  return file.content_type if file.respond_to?(:content_type) # E.g., Rails uploaded file
  path = file_name || file_path(file) rescue nil
  mime_types = MIME::Types.of(path) rescue []                 # MIME::Types.of blows up on nil
  mime_types.empty? ? DEFAULT_MIME_TYPE : mime_types.first.content_type
end
path_from_uri(uri) click to toggle source

Return file path for URI string Should reverse .path_to_uri “file:/path/to/file” => “/path/to/file”

# File lib/ddr/utils.rb, line 67
def self.path_from_uri(uri)
  URI.unescape(URI.parse(uri).path)
end
path_to_uri(path) click to toggle source

Return URI string for file path Should reverse .path_from_uri “/path/to/file” => “file:/path/to/file”

# File lib/ddr/utils.rb, line 74
def self.path_to_uri(path)
  uri = URI.parse(URI.escape(path))
  uri.scheme = "file"
  uri.to_s
end
pid_for_identifier(identifier, opts={}) click to toggle source

Find an object with a given identifier and return its PID. Returns the PID if a single object is found. Returns nil if no object is found. Raises Ddr::Models::Error if more than one object is found. Options can be provided to limit the scope of matching objects

model: Will only consider objects of that model
collection: Will only consider objects that either are that collection or which are
   direct children of that collection (i.e., effectively searches a collection and its
   items for an object with the given identifier)
# File lib/ddr/utils.rb, line 93
def self.pid_for_identifier(identifier, opts={})
  Deprecation.warn(self, "`Ddr::Utils.pid_for_identifier` is deprecated. Use .having_local_id model class method and get id from result object(s). (#{caller.first})")
  model = opts.fetch(:model, nil)
  collection = opts.fetch(:collection, nil)
  objs = []
  ActiveFedora::Base.find_each( { Ddr::Index::Fields::IDENTIFIER_ALL => identifier }, { :cast => true } ) { |o| objs << o }
  pids = []
  objs.each { |obj| pids << obj.id }
  if model.present?
    objs.each { |obj| pids.delete(obj.id) unless obj.is_a?(model.constantize) }
  end
  if collection.present?
    objs.each do |obj|
      pids.delete(obj.id) unless obj == collection || obj.parent == collection
    end
  end
  case pids.size
  when 0
    nil
  when 1
    pids.first
  else
    raise Ddr::Models::Error, I18n.t('ddr.errors.multiple_object_matches', :criteria => "identifier #{identifier}")
  end
end
reflection_object_class(reflection) click to toggle source

Returns the class associated with the :class_name attribute in the options of a reflection E.g., reflection_object_class(relationship_object_reflection(“Item”, “parent”)) returns the Collection class.

# File lib/ddr/utils.rb, line 144
def self.reflection_object_class(reflection)
  reflection_object_model = nil
  klass = nil
  if reflection[1].options[:class_name]
    reflection_object_model = reflection[1].options[:class_name]
  else
    reflection_object_model = ActiveSupport::Inflector.camelize(reflection[0])
  end
  if reflection_object_model
    begin
      klass = reflection_object_model.constantize
    rescue NameError
      # nothing to do here except that we can't return the reflection object class
    end
  end
  return klass
end
relationship_object_reflection(model, relationship_name) click to toggle source

Returns the reflection object for a given model name and relationship name E.g., relationship_object_reflection(“Item”, “parent”) returns the reflection object for an Item's parent relationship. This reflection object can then be used to obtain the class of the relationship object using the reflection_object_class(reflection) method below.

# File lib/ddr/utils.rb, line 123
def self.relationship_object_reflection(model, relationship_name)
  reflection = nil
  if model
    begin
      reflections = model.constantize.reflections
    rescue NameError
      # nothing to do here except that we can't return the appropriate reflection
    else
      reflections.each do |reflect|
        if reflect[0].eql?(relationship_name.to_sym)
          reflection = reflect
        end
      end
    end
  end
  return reflection
end
sanitize_filename(file_name) click to toggle source
# File lib/ddr/utils.rb, line 57
def self.sanitize_filename(file_name)
  return unless file_name
  raise ArgumentError, "file_name argument must be a string" unless file_name.is_a?(String)
  raise ArgumentError, "file_name argument must not include path" if file_name.include?(File::SEPARATOR)
  file_name.gsub(/[^\w\.\-]/,"_")
end
solr_date(dt) click to toggle source

Returns a string suitable to index as a Solr date @param dt [Date, DateTime, Time] the date/time @return [String]

# File lib/ddr/utils.rb, line 165
def self.solr_date(dt)
  return if dt.nil?
  dt.to_time.utc.iso8601
end
solr_dates(dts) click to toggle source
# File lib/ddr/utils.rb, line 170
def self.solr_dates(dts)
  dts.map { |dt| solr_date(dt) }
end