ddr-core 0.2.1

data/lib/ddr/structures/component_type_term.rb

@@ -0,0 +1,29 @@
+module Ddr::Structures
+  class ComponentTypeTerm
+
+    CONFIG_FILE = ::File.join(Rails.root, 'config', 'structure_component_type.yml')
+
+    @@lookup = {}
+
+    def self.term(media_type)
+      hit = lookup_table.detect { |k,v| media_type =~ k }
+      hit.last if hit
+    end
+
+    def self.lookup_table
+      load_lookup if @@lookup.empty?
+      @@lookup
+    end
+
+    def self.load_lookup
+      config = YAML::load(::File.read(CONFIG_FILE))
+      config.each do |type_term, media_types|
+        media_types.each do |media_type|
+          lookup_key = Regexp.new("\\A#{media_type.gsub('*', '.*')}\\Z")
+          @@lookup[lookup_key] = type_term
+        end
+      end
+    end
+
+  end
+end

data/lib/ddr/structures/div.rb

@@ -0,0 +1,64 @@
+module Ddr::Structures
+  #
+  # Wraps a Nokogiri (XML) 'div' node
+  #
+  class Div < SimpleDelegator
+
+    def id
+      self['ID']
+    end
+
+    def label
+      self['LABEL']
+    end
+
+    def order
+      self['ORDER']
+    end
+
+    def orderlabel
+      self['ORDERLABEL']
+    end
+
+    def type
+      self['TYPE']
+    end
+
+    def divs
+      xpath('xmlns:div').map { |node| Div.new(node) }
+    end
+
+    def fptrs
+      xpath('xmlns:fptr').map { |node| Fptr.new(node) }
+    end
+
+    def mptrs
+      xpath('xmlns:mptr').map { |node| Mptr.new(node) }
+    end
+
+    def <=>(other)
+      order.to_i <=> other.order.to_i
+    end
+
+    def dereferenced_hash
+      contents = []
+      contents.concat(divs.map { |div| div.dereferenced_hash }) unless divs.empty?
+      contents.concat(fptrs.map { |fptr| fptr.dereferenced_hash }) unless fptrs.empty?
+      contents.concat(mptrs.map { |mptr| mptr.dereferenced_hash }) unless mptrs.empty?
+      dh = { id: id, label: label, order: order, orderlabel: orderlabel, type: type }.compact
+      dh[:contents] = contents unless contents.empty?
+      dh
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('div', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node['LABEL'] = args[:label] if args[:label]
+      node['ORDER'] = args[:order] if args[:order]
+      node['ORDERLABEL'] = args[:orderlabel] if args[:orderlabel]
+      node['TYPE'] = args[:type] if args[:type]
+      node
+    end
+
+  end
+end

data/lib/ddr/structures/f_locat.rb

@@ -0,0 +1,54 @@
+module Ddr::Structures
+  #
+  # Wraps a Nokogiri (XML) 'FLocat' node
+  #
+  class FLocat < SimpleDelegator
+
+    def id
+      self['ID']
+    end
+
+    def loctype
+      self['LOCTYPE']
+    end
+
+    def otherloctype
+      self['OTHERLOCTYPE']
+    end
+
+    def use
+      self['USE']
+    end
+
+    def href
+      self['xlink:href']
+    end
+
+    def ark?
+      loctype == 'ARK'
+    end
+
+    def ark
+      href if ark?
+    end
+
+    def effective_use
+      use ? use : File.new(parent).effective_use
+    end
+
+    def repo_id
+      SolrDocument.find_by_permanent_id(ark).id if ark?
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('FLocat', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node['LOCTYPE'] = args[:loctype] if args[:loctype]
+      node['OTHERLOCTYPE'] = args[:otherloctype] if args[:otherloctype]
+      node['USE'] = args[:use] if args[:use]
+      node['xlink:href'] = args[:href] if args[:href]
+      node
+    end
+
+  end
+end

data/lib/ddr/structures/file.rb

@@ -0,0 +1,52 @@
+module Ddr::Structures
+  #
+  # Wraps a Nokogiri (XML) 'file' node
+  #
+  class File < SimpleDelegator
+
+    def id
+      self['ID']
+    end
+
+    def use
+      self['USE']
+    end
+
+    def files
+      xpath('xmlns:file').map { |node| File.new(node) }
+    end
+
+    def flocats
+      xpath('xmlns:FLocat').map { |node| FLocat.new(node) }
+    end
+
+    def effective_use
+      if use
+        use
+      else
+        case parent.name
+          when "file"
+            File.new(parent).effective_use
+          when "fileGrp"
+            FileGrp.new(parent).effective_use
+        end
+      end
+    end
+
+    def repo_ids
+      flocats.map(&:repo_id)
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('file', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node['USE'] = args[:use] if args[:use]
+      node
+    end
+
+    def self.find(structure, fileid)
+      structure.files[fileid]
+    end
+
+  end
+end

data/lib/ddr/structures/file_grp.rb

@@ -0,0 +1,35 @@
+module Ddr::Structures
+  #
+  # Wraps a Nokogiri (XML) 'fileGrp' node
+  #
+  class FileGrp < SimpleDelegator
+
+    def id
+      self['ID']
+    end
+
+    def use
+      self['USE']
+    end
+
+    def filegrps
+      xpath('xmlns:filegrp').map { |node| FileGrp.new(node) }
+    end
+
+    def files
+      xpath('xmlns:file').map { |node| File.new(node) }
+    end
+
+    def effective_use
+      use
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('fileGrp', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node['USE'] = args[:use] if args[:use]
+      node
+    end
+
+  end
+end

data/lib/ddr/structures/file_sec.rb

@@ -0,0 +1,22 @@
+module Ddr::Structures
+  #
+  # Wraps a Nokogiri (XML) 'fileSec' node
+  #
+  class FileSec < SimpleDelegator
+
+    def id
+      self['ID']
+    end
+
+    def filegrps
+      xpath('xmlns:fileGrp').map { |node| FileGrp.new(node) }
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('fileSec', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node
+    end
+
+  end
+end

data/lib/ddr/structures/fptr.rb

@@ -0,0 +1,31 @@
+module Ddr::Structures
+  #
+  # Wraps a Nokogiri (XML) 'fptr' node
+  #
+  class Fptr < SimpleDelegator
+
+    def id
+      self['ID']
+    end
+
+    def fileid
+      self['FILEID']
+    end
+
+    def dereferenced_hash
+      structure = Ddr::Structure.new(document)
+      file = File.find(structure, fileid)
+      repo_id = file.repo_ids.first
+      use = file.flocats.first.effective_use
+      { id: id, repo_id: repo_id, use: use }.compact
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('fptr', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node['FILEID'] = args[:fileid] if args[:fileid]
+      node
+    end
+
+  end
+end

data/lib/ddr/structures/mets_hdr.rb

@@ -0,0 +1,37 @@
+module Ddr::Structures
+  #
+  # Wraps a Nokogiri (XML) 'metsHdr' node
+  #
+  class MetsHdr < SimpleDelegator
+
+    def id
+      self['ID']
+    end
+
+    def createdate
+      self['CREATEDATE']
+    end
+
+    def lastmoddate
+      self['LASTMODDATE']
+    end
+
+    def recordstatus
+      self['RECORDSTATUS']
+    end
+
+    def agents
+      xpath('xmlns:agent').map { |node| Agent.new(node) }
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('metsHdr', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node['CREATEDATE'] = args[:createdate] if args[:createdate]
+      node['LASTMODDATE'] = args[:lastmoddate] if args[:lastmoddate]
+      node['RECORDSTATUS'] = args[:recordstatus] if args[:recordstatus]
+      node
+    end
+
+  end
+end

data/lib/ddr/structures/mptr.rb

@@ -0,0 +1,49 @@
+module Ddr::Structures
+  #
+  # Wraps a Nokogiri (XML) 'mptr' node
+  #
+  class Mptr < SimpleDelegator
+
+    def id
+      self['ID']
+    end
+
+    def loctype
+      self['LOCTYPE']
+    end
+
+    def otherloctype
+      self['OTHERLOCTYPE']
+    end
+
+    def href
+      self['xlink:href']
+    end
+
+    def ark?
+      loctype == 'ARK'
+    end
+
+    def ark
+      href if ark?
+    end
+
+    def repo_id
+      SolrDocument.find_by_permanent_id(ark).id if ark?
+    end
+
+    def dereferenced_hash
+      { id: id, repo_id: repo_id }.compact
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('mptr', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node['LOCTYPE'] = args[:loctype] if args[:loctype]
+      node['OTHERLOCTYPE'] = args[:otherloctype] if args[:otherloctype]
+      node['xlink:href'] = args[:href] if args[:href]
+      node
+    end
+
+  end
+end

data/lib/ddr/structures/struct_map.rb

@@ -0,0 +1,40 @@
+module Ddr::Structures
+  #
+  # Wraps a Nokogiri (XML) 'structMap' node
+  #
+  class StructMap < SimpleDelegator
+
+    def id
+      self['ID']
+    end
+
+    def label
+      self['LABEL']
+    end
+
+    def type
+      self['TYPE']
+    end
+
+    def divs
+      xpath('xmlns:div').map { |node| Div.new(node) }
+    end
+
+    def dereferenced_hash
+      contents = []
+      contents.concat(divs.map { |div| div.dereferenced_hash }) unless divs.empty?
+      dh = { id: id, label: label, type: type }.compact
+      dh[:contents] = contents unless contents.empty?
+      dh
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('structMap', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node['LABEL'] = args[:label] if args[:label]
+      node['TYPE'] = args[:type] if args[:type]
+      node
+    end
+
+  end
+end

data/lib/ddr/utils.rb

@@ -0,0 +1,185 @@
+require 'openssl'
+
+module Ddr::Utils
+  extend Deprecation
+
+  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
+
+  def self.file_or_path?(file)
+    file_path(file)
+  rescue ArgumentError
+    false
+  end
+
+  def self.file_path?(file)
+    # length is a sanity check
+    file.is_a?(String) && (file.length < 1024) && File.exist?(file)
+  end
+
+  def self.file_path(file)
+    if file.respond_to?(:path)
+      ::File.absolute_path(file.path)
+    elsif file_path?(file)
+      file
+    else
+      raise ArgumentError, "Argument is neither a File nor a path to an existing file."
+    end
+  end
+
+  def self.file_name_for(file)
+    if file.respond_to?(:original_filename) && file.original_filename.present?
+      file.original_filename
+    else
+      File.basename file_path(file)
+    end
+  end
+
+  def self.file_uri?(uri)
+    return false unless uri
+    URI.parse(uri).scheme == "file"
+  end
+
+  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
+
+  # Return file path for URI string
+  # Should reverse .path_to_uri
+  # "file:/path/to/file" => "/path/to/file"
+  # @param uri [String] The URI string to pathify
+  # @return [String] the file path
+  def self.path_from_uri(uri_string)
+    uri = URI.parse(uri_string)
+    unless uri.scheme == "file"
+      raise ArgumentError, "URI does not have the file: scheme."
+    end
+    URI.unescape(uri.path)
+  end
+
+  # Return URI string for file path
+  # Should reverse .path_from_uri
+  # "/path/to/file" => "file:/path/to/file"
+  # @param path [String] the file path
+  # @return [String] the file: URI string
+  def self.path_to_uri(path)
+    uri = URI.parse URI.escape(path)
+    uri.scheme = "file"
+    uri.to_s
+  end
+
+  def self.ds_as_of_date_time(ds)
+    ds.create_date_string
+  end
+
+  ### DDRevo ################################
+  # Needs replacements for ActiveFedora::Base.find_each call.
+  ### DDRevo ################################
+  # # # 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)
+  # def self.pid_for_identifier(identifier, opts={})
+  #   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.pid }
+  #   if model.present?
+  #     objs.each { |obj| pids.delete(obj.pid) unless obj.is_a?(model.constantize) }
+  #   end
+  #   if collection.present?
+  #     objs.each do |obj|
+  #       pids.delete(obj.pid) 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
+
+  ### DDRevo ################################
+  # This probably isn't relevant in DDRevo context.
+  ### DDRevo ################################
+  # # 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.
+  # 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
+
+  ### DDRevo ################################
+  # This probably isn't relevant in DDRevo context.
+  ### DDRevo ################################
+  # # 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.
+  # 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
+
+  # Returns a string suitable to index as a Solr date
+  # @param dt [Date, DateTime, Time] the date/time
+  # @return [String]
+  def self.solr_date(dt)
+    return if dt.nil?
+    dt.to_time.utc.iso8601
+  end
+
+  def self.solr_dates(dts)
+    dts.map { |dt| solr_date(dt) }
+  end
+
+  class << self
+    alias_method :file_name, :file_name_for
+  end
+
+end