assembly-objectfile 1.8.2 → 1.10.1

data/assembly-objectfile.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.push File.expand_path('lib', __dir__)
 require 'assembly-objectfile/version'
 
@@ -12,14 +14,18 @@ Gem::Specification.new do |s|
   s.description = 'Get exif data, file sizes and more.'
   s.license     = 'ALv2'
 
-  s.rubyforge_project = 'assembly-objectfile'
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.bindir        = 'exe'
   s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
   s.require_paths = ['lib']
 
+  s.required_ruby_version = '~> 2.5'
+
+  s.add_dependency 'activesupport', '>= 5.2.0'
+  s.add_dependency 'deprecation'
+  s.add_dependency 'dry-struct', '~> 1.0'
+  s.add_dependency 'dry-types', '~> 1.1'
   s.add_dependency 'mime-types', '> 3'
   s.add_dependency 'mini_exiftool'
   s.add_dependency 'nokogiri'
@@ -29,5 +35,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'rubocop'
   s.add_development_dependency 'rubocop-rspec'
-  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'simplecov', '~> 0.17.0' # CodeClimate cannot use SimpleCov >= 0.18.0 for generating test coverage
 end

data/config/boot.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 
 environment  = ENV['ENVIRONMENT'] ||= 'development'
-project_root = File.expand_path(File.dirname(__FILE__) + '/..')
+project_root = File.expand_path("#{File.dirname(__FILE__)}/..")
 
 # Load config for current environment.
-$LOAD_PATH.unshift(project_root + '/lib')
+$LOAD_PATH.unshift("#{project_root}/lib")
 
 require 'assembly-objectfile'

data/lib/assembly-objectfile.rb

@@ -1,36 +1,19 @@
+# frozen_string_literal: true
+
 module Assembly
   # the path to the gem, used to access profiles stored with the gem
-  PATH_TO_GEM = File.expand_path(File.dirname(__FILE__) + '/..')
+  PATH_TO_GEM = File.expand_path("#{File.dirname(__FILE__)}/..")
 
   # if input image is not one of these mime types, it will not be regarded as a valid image for the purpose of generating a JP2 derivative
   VALID_IMAGE_MIMETYPES = ['image/jpeg', 'image/tiff', 'image/tif', 'image/png'].freeze
 
   # if input file has one of these extensions in a 3D object, it will get the 3d resource type
-  VALID_THREE_DIMENSION_EXTENTIONS = ['.obj', '.ply', '.threejs', '.gltf'].freeze
+  VALID_THREE_DIMENSION_EXTENTIONS = ['.obj'].freeze
 
   # the list of mimetypes that will be "trusted" by the unix file command; if a mimetype other than one of these is returned
   #  by the file command, then a check will be made to see if exif data exists...if so, the mimetype returned by the exif data will be used
   #  if no exif data exists, then the mimetype returned by the unix file command will be used
   TRUSTED_MIMETYPES = ['text/plain', 'plain/text', 'application/pdf', 'text/html', 'application/xml'].freeze
-
-  # default publish/preserve/shelve attributes used in content metadata
-  FILE_ATTRIBUTES = {}
-  # if no mimetype specific attributes are specified for a given file, define some defaults, and override for specific mimetypes below
-  FILE_ATTRIBUTES['default'] = { preserve: 'yes', shelve: 'no', publish: 'no' }
-  FILE_ATTRIBUTES['image/tif'] = { preserve: 'yes', shelve: 'no', publish: 'no' }
-  FILE_ATTRIBUTES['image/tiff'] = { preserve: 'yes', shelve: 'no', publish: 'no' }
-  FILE_ATTRIBUTES['image/jp2'] = { preserve: 'no', shelve: 'yes', publish: 'yes' }
-  FILE_ATTRIBUTES['image/jpeg'] = { preserve: 'yes', shelve: 'no', publish: 'no' }
-  FILE_ATTRIBUTES['audio/wav'] = { preserve: 'yes', shelve: 'no', publish: 'no' }
-  FILE_ATTRIBUTES['audio/x-wav'] = { preserve: 'yes', shelve: 'no', publish: 'no' }
-  FILE_ATTRIBUTES['audio/mp3'] = { preserve: 'no', shelve: 'yes', publish: 'yes' }
-  FILE_ATTRIBUTES['audio/mpeg'] = { preserve: 'no', shelve: 'yes', publish: 'yes' }
-  FILE_ATTRIBUTES['application/pdf'] = { preserve: 'yes', shelve: 'yes', publish: 'yes' }
-  FILE_ATTRIBUTES['plain/text'] = { preserve: 'yes', shelve: 'yes', publish: 'yes' }
-  FILE_ATTRIBUTES['text/plain'] = { preserve: 'yes', shelve: 'yes', publish: 'yes' }
-  FILE_ATTRIBUTES['image/png'] = { preserve: 'yes', shelve: 'yes', publish: 'no'}
-  FILE_ATTRIBUTES['application/zip'] = { preserve: 'yes', shelve: 'no', publish: 'no' }
-  FILE_ATTRIBUTES['application/json'] = { preserve: 'yes', shelve: 'yes', publish: 'yes' }
 end
 
 require 'assembly-objectfile/content_metadata'

data/lib/assembly-objectfile/content_metadata.rb

@@ -1,10 +1,20 @@
+# frozen_string_literal: true
+
 require 'nokogiri'
+require 'deprecation'
+require 'active_support'
+require 'assembly-objectfile/content_metadata/file'
+require 'assembly-objectfile/content_metadata/file_set'
+require 'assembly-objectfile/content_metadata/file_set_builder'
+require 'assembly-objectfile/content_metadata/config'
+require 'assembly-objectfile/content_metadata/nokogiri_builder'
 
 module Assembly
   SPECIAL_DPG_FOLDERS = %w[31 44 50].freeze # these special dpg folders will force any files contained in them into their own resources, regardless of filenaming convention
   # these are used when :bundle=>:dpg only
 
   DEPRECATED_STYLES = %i[book_with_pdf book_as_image].freeze
+  VALID_STYLES = %i[simple_image simple_book file map document 3d webarchive-seed].freeze
 
   # This class generates content metadata for image files
   class ContentMetadata
@@ -24,6 +34,7 @@ module Assembly
     #                 :book_as_image, as simple_book, but with contentMetadata type="book", resource type="image" (same rule applies for resources with non images)  - NOTE: THIS IS DEPRECATED
     #                 :map, like simple_image, but with contentMetadata type="map", resource type="image"
     #                 :3d, contentMetadata type="3d", ".obj" and other configured 3d extension files go into resource_type="3d", everything else into resource_type="file"
+    #                 :webarchive-seed, contentMetadata type="webarchive-seed", resource type="image"
     #   :bundle = optional - a symbol containing the method of bundling files into resources, allowed values are
     #                 :default = all files get their own resources (default)
     #                 :filename = files with the same filename but different extensions get bundled together in a single resource
@@ -43,195 +54,61 @@ module Assembly
     #   :auto_labels = optional - Will add automated resource labels (e.g. "File 1") when labels are not provided by the user.  The default is true.
     # Example:
     #    Assembly::ContentMetadata.create_content_metadata(:druid=>'druid:nx288wh8889',:style=>:simple_image,:objects=>object_files,:add_file_attributes=>false)
-    def self.create_content_metadata(params = {})
-      druid = params[:druid]
-      objects = params[:objects]
-
-      raise 'No objects and/or druid supplied' if druid.nil? || objects.nil?
-
-      pid = druid.gsub('druid:', '') # remove druid prefix when creating IDs
+    def self.create_content_metadata(druid:, objects:, auto_labels: true,
+                                     add_exif: false, bundle: :default, style: :simple_image,
+                                     add_file_attributes: false, file_attributes: {},
+                                     preserve_common_paths: false, flatten_folder_structure: false,
+                                     include_root_xml: nil)
+
+      common_path = find_common_path(objects) unless preserve_common_paths # find common paths to all files provided if needed
+
+      filesets = FileSetBuilder.build(bundle: bundle, objects: objects, style: style)
+      config = Config.new(auto_labels: auto_labels,
+                          flatten_folder_structure: flatten_folder_structure,
+                          add_file_attributes: add_file_attributes,
+                          file_attributes: file_attributes,
+                          add_exif: add_exif,
+                          type: object_level_type(style))
+
+      builder = NokogiriBuilder.build(druid: druid,
+                                      filesets: filesets,
+                                      common_path: common_path,
+                                      config: config)
+
+      if include_root_xml == false
+        builder.doc.root.to_xml
+      else
+        builder.to_xml
+      end
+    end
 
-      style = params[:style] || :simple_image
-      bundle = params[:bundle] || :default
-      add_exif = params[:add_exif] || false
-      auto_labels = (params[:auto_labels].nil? ? true : params[:auto_labels])
-      add_file_attributes = params[:add_file_attributes] || false
-      file_attributes = params[:file_attributes] || {}
-      preserve_common_paths = params[:preserve_common_paths] || false
-      flatten_folder_structure = params[:flatten_folder_structure] || false
-      include_root_xml = params[:include_root_xml]
+    def self.special_dpg_folder?(folder)
+      SPECIAL_DPG_FOLDERS.include?(folder)
+    end
 
-      all_paths = []
-      objects.flatten.each do |obj|
+    def self.find_common_path(objects)
+      all_paths = objects.flatten.map do |obj|
         raise "File '#{obj.path}' not found" unless obj.file_exists?
 
-        all_paths << obj.path unless preserve_common_paths # collect all of the filenames into an array
+        obj.path # collect all of the filenames into an array
       end
 
-      common_path = Assembly::ObjectFile.common_path(all_paths) unless preserve_common_paths # find common paths to all files provided if needed
-
-      # these are the valid strings for each type of document to be use contentMetadata type and resourceType
-      content_type_descriptions = { file: 'file', image: 'image', book: 'book', map: 'map', '3d': '3d' }
-      resource_type_descriptions = { object: 'object', file: 'file', image: 'image', book: 'page', map: 'image', '3d': '3d' }
-
-      # global sequence for resource IDs
-      sequence = 0
+      Assembly::ObjectFile.common_path(all_paths) # find common paths to all files provided if needed
+    end
+    private_class_method :find_common_path
 
-      # a counter to use when creating auto-labels for resources, with incremenets for each type
-      resource_type_counters = Hash.new(0)
+    def self.object_level_type(style)
+      Deprecation.warn(self, "the style #{style} is now deprecated and should not be used. This will be removed in assembly-objectfile 2.0") if DEPRECATED_STYLES.include? style
+      raise "Supplied style (#{style}) not valid" unless (VALID_STYLES + DEPRECATED_STYLES).include? style
 
-      # set the object level content type id
       case style
       when :simple_image
-        content_type_description = content_type_descriptions[:image]
-      when :file
-        content_type_description = content_type_descriptions[:file]
+        'image'
       when :simple_book, :book_with_pdf, :book_as_image
-        content_type_description = content_type_descriptions[:book]
-      when :map
-        content_type_description = content_type_descriptions[:map]
-      when :'3d'
-        content_type_description = content_type_descriptions[:'3d']
-      else
-        raise "Supplied style (#{style}) not valid"
-      end
-
-      puts "WARNING - the style #{style} is now deprecated and should not be used." if DEPRECATED_STYLES.include? style
-
-      # determine how many resources to create
-      # setup an array of arrays, where the first array is the number of resources, and the second array is the object files containined in that resource
-      case bundle
-      when :default # one resource per object
-        resources = objects.collect { |obj| [obj] }
-      when :filename # one resource per distinct filename (excluding extension)
-        # loop over distinct filenames, this determines how many resources we will have and
-        # create one resource node per distinct filename, collecting the relevant objects with the distinct filename into that resource
-        resources = []
-        distinct_filenames = objects.collect(&:filename_without_ext).uniq # find all the unique filenames in the set of objects, leaving off extensions and base paths
-        distinct_filenames.each { |distinct_filename| resources << objects.collect { |obj| obj if obj.filename_without_ext == distinct_filename }.compact }
-      when :dpg # group by DPG filename
-        # loop over distinct dpg base names, this determines how many resources we will have and
-        # create one resource node per distinct dpg base name, collecting the relevant objects with the distinct names into that resource
-        resources = []
-        distinct_filenames = objects.collect(&:dpg_basename).uniq # find all the unique DPG filenames in the set of objects
-        distinct_filenames.each do |distinct_filename|
-          resources << objects.collect { |obj| obj if obj.dpg_basename == distinct_filename && !is_special_dpg_folder?(obj.dpg_folder) }.compact
-        end
-        objects.each { |obj| resources << [obj] if is_special_dpg_folder?(obj.dpg_folder) } # certain subfolders require individual resources for files within them regardless of file-naming convention
-      when :prebundled
-        # if the user specifies this method, they will pass in an array of arrays, indicating resources, so we don't need to bundle in the gem
-        resources = objects
+        'book'
       else
-        raise 'Invalid bundle method'
+        style.to_s
       end
-
-      resources.delete([]) # delete any empty elements
-
-      builder = Nokogiri::XML::Builder.new do |xml|
-        xml.contentMetadata(objectId: druid.to_s, type: content_type_description) do
-          resources.each do |resource_files| # iterate over all the resources
-            # start a new resource element
-            sequence += 1
-            resource_id = "#{pid}_#{sequence}"
-
-            # grab all of the file types within a resource into an array so we can decide what the resource type should be
-            resource_file_types = resource_files.collect(&:object_type)
-            resource_has_non_images = !(resource_file_types - [:image]).empty?
-            resource_from_special_dpg_folder = resource_files.collect { |obj| is_special_dpg_folder?(obj.dpg_folder) }.uniq
-
-            if bundle == :dpg && resource_from_special_dpg_folder.include?(true) # objects in the special DPG folders are always type=object when we using :bundle=>:dpg
-              resource_type_description = resource_type_descriptions[:object]
-            else # otherwise look at the style to determine the resource_type_description
-              case style
-              when :simple_image
-                resource_type_description = resource_type_descriptions[:image]
-              when :file
-                resource_type_description = resource_type_descriptions[:file]
-              when :simple_book # in a simple book project, all resources are pages unless they are *all* non-images -- if so, switch the type to object
-                resource_type_description = resource_has_non_images && resource_file_types.include?(:image) == false ? resource_type_descriptions[:object] : resource_type_descriptions[:book]
-              when :book_as_image # same as simple book, but all resources are images instead of pages, unless we need to switch them to object type
-                resource_type_description = resource_has_non_images && resource_file_types.include?(:image) == false ? resource_type_descriptions[:object] : resource_type_descriptions[:image]
-              when :book_with_pdf # in book with PDF type, if we find a resource with *any* non images, switch it's type from book to object
-                resource_type_description = resource_has_non_images ? resource_type_descriptions[:object] : resource_type_descriptions[:book]
-              when :map
-                resource_type_description = resource_type_descriptions[:map]
-              when :'3d'
-                 resource_extensions = resource_files.collect {|obj| obj.ext}
-                 if (resource_extensions & VALID_THREE_DIMENSION_EXTENTIONS).empty? # if this resource contains no known 3D file extensions, the resource type is file
-                   resource_type_description = resource_type_descriptions[:file]
-                 else # otherwise the resource type is 3d
-                   resource_type_description = resource_type_descriptions[:'3d']
-                 end
-               end
-            end
-
-            resource_type_counters[resource_type_description.to_sym] += 1 # each resource type description gets its own incrementing counter
-
-            xml.resource(id: resource_id, sequence: sequence, type: resource_type_description) do
-              # create a generic resource label if needed
-              resource_label = (auto_labels == true ? "#{resource_type_description.capitalize} #{resource_type_counters[resource_type_description.to_sym]}" : '')
-
-              # but if one of the files has a label, use it instead
-              resource_files.each { |obj| resource_label = obj.label unless obj.label.nil? || obj.label.empty? }
-
-              xml.label(resource_label) unless resource_label.empty?
-
-              resource_files.each do |obj| # iterate over all the files in a resource
-                mimetype = obj.mimetype if add_file_attributes || add_exif # we only need to compute the mimetype if we are adding file attributes or exif info, otherwise skip it for performance reasons
-
-                # set file id attribute, first check the relative_path parameter on the object, and if it is set, just use that
-                if obj.relative_path
-                  file_id = obj.relative_path
-                else
-                  # if the relative_path attribute is not set, then use the path attribute and check to see if we need to remove the common part of the path
-                  file_id = preserve_common_paths ? obj.path : obj.path.gsub(common_path, '')
-                  file_id = File.basename(file_id) if flatten_folder_structure
-                end
-
-                xml_file_params = { id: file_id }
-
-                if add_file_attributes
-                  file_attributes_hash = obj.file_attributes || file_attributes[mimetype] || file_attributes['default'] || Assembly::FILE_ATTRIBUTES[mimetype] || Assembly::FILE_ATTRIBUTES['default']
-                  xml_file_params.merge!(
-                    preserve: file_attributes_hash[:preserve],
-                    publish: file_attributes_hash[:publish],
-                    shelve: file_attributes_hash[:shelve],
-                    role: file_attributes_hash[:role]
-                  )
-                  xml_file_params.reject! { |_k, v| v.nil? || v.empty? }
-                end
-
-                if add_exif
-                  xml_file_params[:mimetype] = mimetype
-                  xml_file_params[:size] = obj.filesize
-                end
-                xml.file(xml_file_params) do
-                  if add_exif # add exif info if the user requested it
-                    xml.checksum(obj.sha1, type: 'sha1')
-                    xml.checksum(obj.md5, type: 'md5')
-                    xml.imageData(height: obj.exif.imageheight, width: obj.exif.imagewidth) if obj.image? # add image data for an image
-                  elsif obj.provider_md5 || obj.provider_sha1 # if we did not add exif info, see if there are user supplied checksums to add
-                    xml.checksum(obj.provider_sha1, type: 'sha1') if obj.provider_sha1
-                    xml.checksum(obj.provider_md5, type: 'md5') if obj.provider_md5
-                  end # add_exif
-                end
-              end # end resource_files.each
-            end
-          end # resources.each
-        end
-      end
-
-      result = if include_root_xml == false
-                 builder.doc.root.to_xml
-               else
-                 builder.to_xml
-               end
-
-      result
-    end # create_content_metadata
-
-    def self.is_special_dpg_folder?(folder)
-      SPECIAL_DPG_FOLDERS.include?(folder)
     end
   end # class
 end # module

data/lib/assembly-objectfile/content_metadata/config.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'dry-types'
+
+module Assembly
+  class ContentMetadata
+    # Types for the configuration
+    module Types
+      include Dry.Types()
+    end
+
+    # Represents a configuration for generating the content metadata
+    class Config < Dry::Struct
+      STYLES = %w[image file book map 3d document webarchive-seed].freeze
+      attribute :auto_labels, Types::Strict::Bool.default(true)
+      attribute :flatten_folder_structure, Types::Strict::Bool.default(false)
+      attribute :add_file_attributes, Types::Strict::Bool.default(false)
+      attribute :add_exif, Types::Strict::Bool.default(false)
+      attribute :file_attributes, Types::Strict::Hash.default({}.freeze)
+      attribute :type, Types::Strict::String.enum(*STYLES)
+    end
+  end
+end

data/lib/assembly-objectfile/content_metadata/file.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+
+module Assembly
+  class ContentMetadata
+    # Represents a single File
+    class File
+      # default publish/preserve/shelve attributes used in content metadata
+      # if no mimetype specific attributes are specified for a given file, define some defaults, and override for specific mimetypes below
+      ATTRIBUTES_FOR_TYPE = {
+        'default' => { preserve: 'yes', shelve: 'no', publish: 'no' },
+        'image/tif' => { preserve: 'yes', shelve: 'no', publish: 'no' },
+        'image/tiff' => { preserve: 'yes', shelve: 'no', publish: 'no' },
+        'image/jp2' => { preserve: 'no', shelve: 'yes', publish: 'yes' },
+        'image/jpeg' => { preserve: 'yes', shelve: 'no', publish: 'no' },
+        'audio/wav' => { preserve: 'yes', shelve: 'no', publish: 'no' },
+        'audio/x-wav' => { preserve: 'yes', shelve: 'no', publish: 'no' },
+        'audio/mp3' => { preserve: 'no', shelve: 'yes', publish: 'yes' },
+        'audio/mpeg' => { preserve: 'no', shelve: 'yes', publish: 'yes' },
+        'application/pdf' => { preserve: 'yes', shelve: 'yes', publish: 'yes' },
+        'plain/text' => { preserve: 'yes', shelve: 'yes', publish: 'yes' },
+        'text/plain' => { preserve: 'yes', shelve: 'yes', publish: 'yes' },
+        'image/png' => { preserve: 'yes', shelve: 'yes', publish: 'no' },
+        'application/zip' => { preserve: 'yes', shelve: 'no', publish: 'no' },
+        'application/json' => { preserve: 'yes', shelve: 'yes', publish: 'yes' }
+      }.freeze
+
+      # @param [Symbol] bundle
+      # @param [Assembly::ObjectFile] file
+      # @param style
+      def initialize(file:, bundle: nil, style: nil)
+        @bundle = bundle
+        @file = file
+        @style = style
+      end
+
+      delegate :sha1, :md5, :provider_md5, :provider_sha1, :mimetype, :filesize, :image?, to: :file
+
+      def file_id(common_path:, flatten_folder_structure:)
+        # set file id attribute, first check the relative_path parameter on the object, and if it is set, just use that
+        return file.relative_path if file.relative_path
+
+        # if the relative_path attribute is not set, then use the path attribute and check to see if we need to remove the common part of the path
+        file_id = common_path ? file.path.gsub(common_path, '') : file.path
+        file_id = ::File.basename(file_id) if flatten_folder_structure
+        file_id
+      end
+
+      def file_attributes(provided_file_attributes)
+        file.file_attributes || provided_file_attributes[mimetype] || provided_file_attributes['default'] || ATTRIBUTES_FOR_TYPE[mimetype] || ATTRIBUTES_FOR_TYPE['default']
+      end
+
+      def image_data
+        { height: file.exif.imageheight, width: file.exif.imagewidth }
+      end
+
+      private
+
+      attr_reader :file
+    end
+  end
+end

data/lib/assembly-objectfile/content_metadata/file_set.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+module Assembly
+  class ContentMetadata
+    # Represents a groups of related Files, such as a single master file and the derivatives
+    class FileSet
+      # @param [Boolean] dpg (false) is it a dpg bundle?
+      # @param [Array<Assembly::ObjectFile>] resource_files
+      # @param style
+      def initialize(resource_files:, style:, dpg: false)
+        @dpg = dpg
+        @resource_files = resource_files
+        @style = style
+      end
+
+      # objects in the special DPG folders are always type=object when we using :bundle=>:dpg
+      # otherwise look at the style to determine the resource_type_description
+      def resource_type_description
+        @resource_type_description ||= special_dpg_resource? ? 'object' : resource_type_descriptions
+      end
+
+      def label_from_file(default:)
+        resource_files.find { |obj| obj.label.present? }&.label || default
+      end
+
+      def files
+        resource_files.map { |file| File.new(file: file) }
+      end
+
+      private
+
+      attr_reader :dpg, :resource_files, :style
+
+      def special_dpg_resource?
+        return false unless dpg
+
+        resource_files.collect { |obj| ContentMetadata.special_dpg_folder?(obj.dpg_folder) }.include?(true)
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def resource_type_descriptions
+        # grab all of the file types within a resource into an array so we can decide what the resource type should be
+        resource_file_types = resource_files.collect(&:object_type)
+        resource_has_non_images = !(resource_file_types - [:image]).empty?
+
+        case style
+        when :simple_image, :map, :'webarchive-seed'
+          'image'
+        when :file
+          'file'
+        when :simple_book # in a simple book project, all resources are pages unless they are *all* non-images -- if so, switch the type to object
+          resource_has_non_images && resource_file_types.include?(:image) == false ? 'object' : 'page'
+        when :book_as_image # same as simple book, but all resources are images instead of pages, unless we need to switch them to object type
+          resource_has_non_images && resource_file_types.include?(:image) == false ? 'object' : 'image'
+        when :book_with_pdf # in book with PDF type, if we find a resource with *any* non images, switch it's type from book to object
+          resource_has_non_images ? 'object' : 'page'
+        when :document
+          'document'
+        when :'3d'
+          resource_extensions = resource_files.collect(&:ext)
+          if (resource_extensions & VALID_THREE_DIMENSION_EXTENTIONS).empty? # if this resource contains no known 3D file extensions, the resource type is file
+            'file'
+          else # otherwise the resource type is 3d
+            '3d'
+          end
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+    end
+  end
+end