ddr-models 2.11.0 → 3.0.0.alpha.1

data/lib/ddr/models/metadata/metadata_mapper.rb

@@ -0,0 +1,32 @@
+module Ddr::Models
+  #
+  # Maps vocabulary terms to names
+  #
+  class MetadataMapper
+    extend MetadataMappers
+
+    attr_reader :mapping
+
+    # param vocab [MetadataVocabulary] the vocabulary
+    def initialize(vocab)
+      @mapping = vocab.terms.each_with_object({}) do |term, memo|
+        memo[term.qualified_name] = term
+      end
+    end
+
+    def terms
+      mapping.values
+    end
+
+    def unqualified_names
+      mapping.values.map(&:unqualified_name)
+    end
+
+    def merge(other)
+      merged = self.dup
+      merged.mapping.merge! other.mapping
+      merged
+    end
+
+  end
+end

data/lib/ddr/models/metadata/metadata_mappers.rb

@@ -0,0 +1,18 @@
+module Ddr::Models
+  # A registry of common metadata mappers
+  module MetadataMappers
+
+    def dc11
+      MetadataMapper.new(MetadataVocabulary.dc11)
+    end
+
+    def dcterms
+      MetadataMapper.new(MetadataVocabulary.dcterms)
+    end
+
+    def duketerms
+      MetadataMapper.new(MetadataVocabulary.duketerms)
+    end
+
+  end
+end

data/lib/ddr/models/metadata/metadata_term.rb

@@ -0,0 +1,24 @@
+require "delegate"
+
+module Ddr::Models
+  # Wraps an RDF term (RDF::Vocabulary::Term)
+  class MetadataTerm < SimpleDelegator
+
+    def qualified_name
+      qname.join("_").to_sym
+    end
+
+    def unqualified_name
+      qname.last
+    end
+
+    def predicate
+      to_uri
+    end
+
+    def prefix
+      qname.first
+    end
+
+  end
+end

data/lib/ddr/models/metadata/metadata_vocabularies.rb

@@ -0,0 +1,18 @@
+module Ddr::Models
+  # Registry of common metadata vocabularies
+  module MetadataVocabularies
+
+    def dc11
+      MetadataVocabulary.new(RDF::DC11)
+    end
+
+    def dcterms
+      MetadataVocabulary.new(RDF::DC, except: RDF::DC.license)
+    end
+
+    def duketerms
+      MetadataVocabulary.new(Ddr::Vocab::DukeTerms)
+    end
+
+  end
+end

data/lib/ddr/models/metadata/metadata_vocabulary.rb

@@ -0,0 +1,34 @@
+module Ddr::Models
+  class MetadataVocabulary
+    extend MetadataVocabularies
+
+    attr_reader :rdf_vocab, :except, :only_properties
+
+    # @param rdf_vocab [RDF::Vocabulary] an RDF vocabulary class
+    # @param except [RDF::Vocabulary::Term, Array<RDF::Vocabulary::Term>] term(s) to exclude
+    # @param only_properties [Boolean] whether to include only RDF properties
+    #   -- i.e., having RDF type http://www.w3.org/1999/02/22-rdf-syntax-ns#Property
+    #   -- default: true
+    def initialize(rdf_vocab, except: nil, only_properties: true)
+      @rdf_vocab = rdf_vocab
+      @except = Array(except)
+      @only_properties = only_properties
+    end
+
+    # @return [Array<RDF::Vocabulary::Term>]
+    def terms
+      @terms ||= rdf_properties.map { |term| MetadataTerm.new(term) }
+    end
+
+    private
+
+    def rdf_properties
+      props = rdf_vocab.properties
+      if only_properties
+        props.select! { |prop| prop.type.include?("http://www.w3.org/1999/02/22-rdf-syntax-ns#Property") }
+      end
+      props - except
+    end
+
+  end
+end

data/lib/ddr/models/solr_document.rb

@@ -3,9 +3,6 @@ require 'json'
 module Ddr::Models
   module SolrDocument
     extend ActiveSupport::Concern
-    extend Deprecation
-
-    self.deprecation_horizon = 'ddr-models v3.0'
 
     included do
       alias_method :pid, :id
@@ -15,20 +12,13 @@ module Ddr::Models
 
     module ClassMethods
       def find(pid_or_uri)
-        query = Ddr::Index::Query.new { id pid_or_uri.sub(/\Ainfo:fedora\//, "") }
+        pid = pid_or_uri.sub(/\Ainfo:fedora\//, "")
+        query = Ddr::Index::QueryBuilder.build { |q| q.id(pid) }
         if doc = query.docs.first
           return doc
         end
         raise NotFound, "SolrDocument not found for \"#{pid_or_uri}\"."
       end
-
-      def find_by_permanent_id(ark)
-        query = Ddr::Index::Query.new { where permanent_id: ark }
-        if doc = query.docs.first
-          return doc
-        end
-        raise NotFound, "SolrDocument not found for permanent id \"#{ark}\"."
-      end
     end
 
     def inspect
@@ -141,14 +131,6 @@ module Ddr::Models
       has_datastream?(Ddr::Datastreams::CONTENT)
     end
 
-    def has_intermediate_file?
-      has_datastream?(Ddr::Datastreams::INTERMEDIATE_FILE)
-    end
-
-    def has_extracted_text?
-      has_datastream?(Ddr::Datastreams::EXTRACTED_TEXT)
-    end
-
     def content_ds
       datastreams[Ddr::Datastreams::CONTENT]
     end
@@ -183,20 +165,22 @@ module Ddr::Models
       active_fedora_model.tableize
     end
 
-    def rights_statement
-      @rights_statement ||= RightsStatement.call(self)
+    def effective_license
+      @effective_license ||= EffectiveLicense.call(self)
     end
-    alias_method :effective_license, :rights_statement
-    deprecation_deprecate :effective_license
 
     def roles
       @roles ||= Ddr::Auth::Roles::DetachedRoleSet.from_json(access_role)
     end
 
-    def structure
-      JSON.parse(fetch(Ddr::Index::Fields::STRUCTURE))
+    def struct_maps
+      JSON.parse(fetch(Ddr::Index::Fields::STRUCT_MAPS))
     rescue
-      nil
+      {}
+    end
+
+    def struct_map(type='default')
+      struct_maps.present? ? struct_maps.fetch(type) : nil
     end
 
     def effective_permissions(agents)
@@ -205,7 +189,7 @@ module Ddr::Models
 
     def research_help
       research_help_contact = self[Ddr::Index::Fields::RESEARCH_HELP_CONTACT] || inherited_research_help_contact
-      Ddr::Models::Contact.call(research_help_contact) if research_help_contact
+      Ddr::Contacts.get(research_help_contact) if research_help_contact
     end
 
     def parent_uri
@@ -222,12 +206,8 @@ module Ddr::Models
       end
     end
 
-    def multires_image_file_paths
-      if structure
-        structure_docs.map { |doc| doc.multires_image_file_path }.compact
-      else
-        []
-      end
+    def multires_image_file_paths(type='default')
+      struct_map_docs(type).map { |doc| doc.multires_image_file_path }.compact
     end
 
     # DRY HasAdminMetadata
@@ -237,92 +217,6 @@ module Ddr::Models
       end
     end
 
-    def intermediate_type
-      if has_intermediate_file?
-        datastreams[Ddr::Datastreams::INTERMEDIATE_FILE]["dsMIME"]
-      end
-    end
-
-    def intermediate_path
-      if has_intermediate_file?
-        Ddr::Utils.path_from_uri(datastreams[Ddr::Datastreams::INTERMEDIATE_FILE]["dsLocation"])
-      end
-    end
-
-    def intermediate_extension
-      if has_intermediate_file?
-        extensions = Ddr::Models.preferred_file_extensions
-        if extensions.include? intermediate_type
-          extensions[intermediate_type]
-        else
-          intermediate_extension_default
-        end
-      end
-    end
-
-    def captionable?
-      has_datastream?(Ddr::Datastreams::CAPTION)
-    end
-
-    def caption_type
-      if captionable?
-        datastreams[Ddr::Datastreams::CAPTION]["dsMIME"]
-      end
-    end
-
-    def caption_extension
-      if captionable?
-        extensions = Ddr::Models.preferred_file_extensions
-        if extensions.include? caption_type
-          extensions[caption_type]
-        else
-          caption_extension_default
-        end
-      end
-    end
-
-    def caption_path
-      if captionable?
-        Ddr::Utils.path_from_uri(datastreams[Ddr::Datastreams::CAPTION]["dsLocation"])
-      end
-    end
-
-    def streamable?
-      has_datastream?(Ddr::Datastreams::STREAMABLE_MEDIA)
-    end
-
-    def streamable_media_extension
-      if streamable?
-        extensions = Ddr::Models.preferred_file_extensions
-        if extensions.include? streamable_media_type
-          extensions[streamable_media_type]
-        else
-          streamable_media_extension_default
-        end
-      end
-    end
-
-    def streamable_media_type
-      if streamable?
-        datastreams[Ddr::Datastreams::STREAMABLE_MEDIA]["dsMIME"]
-      end
-    end
-
-    def streamable_media_path
-      if streamable?
-        Ddr::Utils.path_from_uri(datastreams[Ddr::Datastreams::STREAMABLE_MEDIA]["dsLocation"])
-      end
-    end
-
-    # FIXME - Probably need a more general solution mapping object reader methods to index field names.
-    def rights
-      self["rights_tesim"]
-    end
-
-    def children
-      children_query.docs rescue []
-    end
-
     private
 
     def targets_query
@@ -355,45 +249,19 @@ module Ddr::Models
       end
     end
 
-    def structure_docs
-      structure_repo_ids.map { |repo_id| self.class.find(repo_id) }.compact
-    end
-
-    # For simplicity, initial implementation returns repo ID's only from top-level
-    # (i.e., not nested) contents.  This is done since we have not clarified what
-    # an _ordered_ list of repo ID's should look like if structure contains nested
-    # contents.
-    def structure_repo_ids
-      default_struct_map['contents'].map { |content| content['contents'].map { |content| content['repo_id'] } }.flatten
-    end
-
-    def default_struct_map
-      structure['default'] || structure.values.first
-    end
-
-    def intermediate_extension_default
-      datastreams[Ddr::Datastreams::INTERMEDIATE_FILE].default_file_extension
-    end
-
-    def caption_extension_default
-      datastreams[Ddr::Datastreams::CAPTION].default_file_extension
+    def struct_map_docs(type='default')
+      struct_map_pids(type).map { |pid| self.class.find(pid) }.compact
     end
 
-    def streamable_media_extension_default
-      datastreams[Ddr::Datastreams::STREAMABLE_MEDIA].default_file_extension
+    # For simplicity, initial implementation returns PID's only from top-level
+    # (i.e., not nested) div's.  This is done since we have not clarified what
+    # an _ordered_ list of PID's should look like if struct map contains nested
+    # div's.
+    def struct_map_pids(type='default')
+      struct_map(type)['divs'].map { |d| d['fptrs'].present? ? d['fptrs'].first : nil}.compact
+    rescue
+      []
     end
 
-    def children_query
-      case self[Ddr::Index::Fields::ACTIVE_FEDORA_MODEL]
-        when 'Collection'
-          Ddr::Index::Query.build(self) do |parent|
-            is_member_of_collection parent.id
-          end
-        when 'Item'
-          Ddr::Index::Query.build(self) do |parent|
-            is_part_of parent.id
-          end
-      end
-    end
   end
 end

data/lib/ddr/models/struct_div.rb

@@ -0,0 +1,63 @@
+module Ddr
+  module Models
+    class StructDiv
+
+      attr_accessor :id, :label, :order, :orderlabel, :type, :fptrs, :divs
+
+      def initialize(structmap_or_div_node)
+        @id = structmap_or_div_node['ID']
+        @label = structmap_or_div_node['LABEL']
+        @order = structmap_or_div_node['ORDER']
+        @orderlabel = structmap_or_div_node['ORDERLABEL']
+        @type = structmap_or_div_node['TYPE']
+        @fptrs = fptr_pids(structmap_or_div_node) if structmap_or_div_node.node_name == "div"
+        @divs = subdivs(structmap_or_div_node).sort
+      end
+
+      def <=>(other)
+        self.order.to_i <=> other.order.to_i
+      end
+
+      def pids
+        collect_pids(self)
+      end
+
+      def docs
+        query = ActiveFedora::SolrService.construct_query_for_pids(pids)
+        results = ActiveFedora::SolrService.query(query, rows: 999999)
+        results.each_with_object({}) do |r, memo|
+          memo[r["id"]] = ::SolrDocument.new(r)
+        end
+      end
+
+      def objects
+        pids.each_with_object({}) do |pid, memo|
+          memo[pid] = ActiveFedora::Base.find(pid)
+        end
+      end
+
+      def as_json(options={})
+        super.compact
+      end
+
+      private
+
+      def fptr_pids(div_node)
+        div_node.xpath('xmlns:fptr').map { |fptr_node| fptr_node["CONTENTIDS"].gsub('info:fedora/', '') }
+      end
+
+      def subdivs(structmap_or_div_node)
+        structmap_or_div_node.xpath('xmlns:div').map { |div_node| Ddr::Models::StructDiv.new(div_node) }
+      end
+
+      def collect_pids(structdiv)
+        pids = structdiv.divs.each_with_object([]) do |div, memo|
+          memo << collect_pids(div)
+        end
+        pids << structdiv.fptrs if structdiv.fptrs
+        pids.flatten
+      end
+
+    end
+  end
+end

data/lib/ddr/models/structure.rb

@@ -1,188 +1,52 @@
-module Ddr::Models
-  #
-  # Wraps a Nokogiri (XML) 'mets' Document
-  #
-  class Structure < SimpleDelegator
-
-    # Indicates whether the structure is externally provided or maintained by the repository itself (i.e., is the
-    # default structure for the object).
-    EXTERNALLY_PROVIDED = 'provided'.freeze
-    REPOSITORY_MAINTAINED = 'repository'.freeze
-
-    TYPE_DEFAULT = 'default'.freeze
-
-    # Based on the PCDM Extension 'Use' ontology -- https://github.com/duraspace/pcdm/blob/master/pcdm-ext/use.rdf
-    USE_EXTRACTED_TEXT = 'ExtractedText'.freeze
-    USE_INTERMEDIATE_FILE = 'IntermediateFile'.freeze
-    USE_ORIGINAL_FILE = 'OriginalFile'.freeze
-    USE_PRESERVATION_MASTER_FILE = 'PreservationMasterFile'.freeze
-    USE_SERVICE_FILE = 'ServiceFile'.freeze
-    USE_THUMBNAIL_IMAGE = 'ThumbnailImage'.freeze
-    USE_TRANSCRIPT = 'Transcript'.freeze
-
-    def filesec
-      @filesec ||= Ddr::Models::Structures::FileSec.new(fileSec_node)
-    end
-
-    def files
-      @files ||= collect_files
-    end
-
-    def uses
-      @uses ||= collect_uses
-    end
-
-    def structmap(type=nil)
-      sm = type ? structMap_node(type) : structMap_nodes.first
-      @structmap ||= Ddr::Models::Structures::StructMap.new(sm)
-    end
-
-    def structmaps
-      @structmaps ||= structMap_nodes.map { |sm| Ddr::Models::Structures::StructMap.new(sm) }
-    end
-
-    def metshdr
-      @metshdr ||=  Ddr::Models::Structures::MetsHdr.new(metsHdr_node)
-    end
-
-    def creator
-      @creator ||= metshdr.empty? ? nil
-                                  : Ddr::Models::Structures::MetsHdr.new(metsHdr_node).agents.first.name
-    end
-
-    def repository_maintained?
-      creator == Ddr::Models::Structures::Agent::NAME_REPOSITORY_DEFAULT
-    end
-
-    def dereferenced_structure
-      deref_struct = {}
-      structmaps.each do |sm|
-        deref_struct[sm.type] = sm.dereferenced_hash
+module Ddr
+  module Models
+    #
+    # Wraps a Nokogiri (XML) Document
+    #
+    class Structure < SimpleDelegator
+
+      def initialize(xml_doc=nil)
+        super
       end
-      deref_struct
-    end
-
-    def as_xml_document
-      __getobj__
-    end
-
-    def add_metshdr(id:nil, createdate:nil, lastmoddate:nil, recordstatus:nil)
-      metshdr = Ddr::Models::Structures::MetsHdr.build(id: id, createdate: createdate, lastmoddate: lastmoddate,
-                                                       recordstatus: recordstatus, document: as_xml_document)
-      root.add_child(metshdr)
-      metshdr
-    end
-
-    def add_agent(parent:, id:nil, role:, otherrole:nil, type:nil, othertype:nil, name:nil)
-      agent = Ddr::Models::Structures::Agent.build(id: id, role: role, otherrole: otherrole, type: type,
-                                                   othertype: othertype, name: name, document: as_xml_document)
-      parent.add_child(agent)
-      agent
-    end
-
-    def add_filesec(id:nil)
-      filesec = Ddr::Models::Structures::FileSec.build(id: id, document: as_xml_document)
-      root.add_child(filesec)
-      filesec
-    end
 
-    def add_filegrp(parent:, id:nil, use:nil)
-      filegrp = Ddr::Models::Structures::FileGrp.build(id: id, use: use, document: as_xml_document)
-      parent.add_child(filegrp)
-      filegrp
-    end
-
-    def add_file(parent:, id:SecureRandom.uuid, use:nil)
-      file = Ddr::Models::Structures::File.build(id: id, use: use, document: as_xml_document)
-      parent.add_child(file)
-      file
-    end
-
-    def add_flocat(parent:, id:nil, loctype:'ARK', otherloctype: nil, use:nil, href:)
-      flocat = Ddr::Models::Structures::FLocat.build(id: id, loctype: loctype, otherloctype: otherloctype, use: use,
-                                                     href: href, document: as_xml_document)
-      parent.add_child(flocat)
-      flocat
-    end
-
-    def add_structmap(id:nil, label:nil, type:)
-      structmap = Ddr::Models::Structures::StructMap.build(id: id, label: label, type: type, document: as_xml_document)
-      root.add_child(structmap)
-      structmap
-    end
-
-    def add_div(parent:, id:nil, label:nil, order:nil, orderlabel: nil, type:nil)
-      div = Ddr::Models::Structures::Div.build(id: id, label: label, order:order, orderlabel: orderlabel, type: type,
-                                               document: as_xml_document)
-      parent.add_child(div)
-      div
-    end
-
-    def add_fptr(parent:, id: nil, fileid:)
-      fptr = Ddr::Models::Structures::Fptr.build(id: id, fileid: fileid, document: as_xml_document)
-      parent.add_child(fptr)
-      fptr
-    end
-
-    def add_mptr(parent:, id: nil, loctype:'ARK', otherloctype: nil, href:)
-      mptr = Ddr::Models::Structures::Mptr.build(id: id, loctype: loctype, otherloctype: otherloctype, href: href,
-                                                 document: as_xml_document)
-      parent.add_child(mptr)
-      mptr
-    end
-
-    private
-
-    def fileSec_node
-      xpath("//xmlns:fileSec").first
-    end
-
-    def structMap_nodes
-      xpath("//xmlns:structMap")
-    end
+      def struct_maps
+        @struct_maps ||= build_struct_maps(structMap_nodes)
+      end
 
-    def structMap_node(type)
-      xpath("//xmlns:structMap[@TYPE='#{type}']").first
-    end
+      def structMap_node(type='default')
+        xpath("//xmlns:structMap[@TYPE='#{type}']").first
+      end
 
-    def metsHdr_node
-      xpath("//xmlns:metsHdr")
-    end
+      def as_xml_document
+        __getobj__
+      end
 
-    def file_nodes
-      xpath("//xmlns:file")
-    end
+      private
 
-    def flocat_nodes
-      xpath("//xmlns:FLocat")
-    end
+      def structMap_nodes
+        xpath("//xmlns:structMap")
+      end
 
-    def collect_files
-      files = {}
-      file_nodes.each do |file_node|
-        file = Ddr::Models::Structures::File.new(file_node)
-        files[file.id] = file
+      def build_struct_maps(structMap_nodes)
+        smaps = {}
+        structMap_nodes.each do |structMap_node|
+          type = structMap_node['TYPE'] || 'default'
+          raise StandardError, "Multiple '#{type}' structMaps" if smaps[type].present?
+          smaps[type] = Ddr::Models::StructDiv.new(structMap_node)
+        end
+        smaps
       end
-      files
-    end
 
-    def collect_uses
-      uses = {}
-      flocat_nodes.each do |flocat_node|
-        flocat = Ddr::Models::Structures::FLocat.new(flocat_node)
-        uses[flocat.effective_use] ||= []
-        uses[flocat.effective_use] << flocat
+      def self.template
+        Nokogiri::XML(
+            '<mets xmlns="http://www.loc.gov/METS/" xmlns:xlink="http://www.w3.org/1999/xlink">
+              <structMap TYPE="default" />
+            </mets>'
+            ) do |config|
+                config.noblanks
+              end
       end
-      uses
-    end
 
-    def self.xml_template
-      Nokogiri::XML(
-          '<mets xmlns="http://www.loc.gov/METS/" xmlns:xlink="http://www.w3.org/1999/xlink" />'
-          ) do |config|
-              config.noblanks
-            end
     end
-
   end
-end
+end