assembly-objectfile 1.8.3 → 1.10.2

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,6 +1,8 @@
+# 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
@@ -12,25 +14,6 @@ module Assembly
   #  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
@@ -41,197 +52,66 @@ module Assembly
     #   :flatten_folder_structure = optional - Will remove *all* folder structure when genearting file IDs (e.g. DPG subfolders like '00','05' will be removed) when generating file IDs.  This is useful if the folder structure is flattened when staging files (like for DPG).
     #                                             The default is false.  If set to true, will override the "preserve_common_paths" parameter.
     #   :auto_labels = optional - Will add automated resource labels (e.g. "File 1") when labels are not provided by the user.  The default is true.
+    #   See https://consul.stanford.edu/pages/viewpage.action?spaceKey=chimera&title=DOR+content+types%2C+resource+types+and+interpretive+metadata for next two settings
+    #   :reading_order = optional - only valid for simple_book, can be 'rtl' or 'ltr'.  The default is 'ltr'.
     # 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, reading_order: 'ltr')
+
+      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,
+                          reading_order: reading_order,
+                          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,26 @@
+# 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
+      READING_ORDERS = %w[ltr rtl].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)
+      attribute :reading_order, Types::Strict::String.default('ltr').enum(*READING_ORDERS)
+    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