assembly-objectfile 1.11.0 → 2.0.0

data/lib/assembly-objectfile/content_metadata.rb

@@ -1,117 +0,0 @@
-# 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
-    # Generates image content XML metadata for a repository object.
-    # This method only produces content metadata for images
-    # and does not depend on a specific folder structure.  Note that it is class level method.
-    #
-    # @param [Hash] params a hash containg parameters needed to produce content metadata
-    #   :druid = required - a string of druid of the repository object's druid id (with or without 'druid:' prefix)
-    #   :objects = required - an array of Assembly::ObjectFile objects containing the list of files to add to content metadata
-    #                NOTE: if you set the :bundle option to :prebundled, you will need to pass in an array of arrays, and not a flat array, as noted below
-    #   :style = optional - a symbol containing the style of metadata to create, allowed values are
-    #                 :simple_image (default), contentMetadata type="image", resource type="image"
-    #                 :file, contentMetadata type="file", resource type="file"
-    #                 :simple_book, contentMetadata type="book", resource type="page", but any resource which has file(s) other than an image, and also contains no images at all, will be resource type="object"
-    #                 :book_with_pdf, contentMetadata type="book", resource type="page", but any resource which has any file(s) other than an image will be resource type="object" - NOTE: THIS IS DEPRECATED
-    #                 :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
-    #                 :dpg = files representing the same image but of different mimetype that use the SULAIR DPG filenaming standard (00 vs 05) get bundled together in a single resource
-    #                 :prebundlded = this option requires you to prebundled the files passed in as an array of arrays, indicating how files are bundlded into resources; this is the most flexible option since it gives you full control
-    #   :add_exif = optional - a boolean to indicate if exif data should be added (mimetype, filesize, image height/width, etc.) to each file, defaults to false and is not required if project goes through assembly
-    #   :add_file_attributes = optional - a boolean to indicate if publish/preserve/shelve/role attributes should be added using defaults or by supplied override by mime/type, defaults to false and is not required if project goes through assembly
-    #   :file_attributes = optional - a hash of file attributes by mimetype to use instead of defaults, only used if add_file_attributes is also true,
-    #             If a mimetype match is not found in your hash, the default is used (either your supplied default or the gems).
-    #             e.g. {'default'=>{:preserve=>'yes',:shelve=>'yes',:publish=>'yes'},'image/tif'=>{:preserve=>'yes',:shelve=>'no',:publish=>'no'},'application/pdf'=>{:preserve=>'yes',:shelve=>'yes',:publish=>'yes'}}
-    #   :include_root_xml = optional - a boolean to indicate if the contentMetadata returned includes a root <?xml version="1.0"?> tag, defaults to true
-    #   :preserve_common_paths = optional - When creating the file "id" attribute, content metadata uses the "relative_path" attribute of the ObjectFile objects passed in.  If the "relative_path" attribute is not set,  the "path" attribute is used instead,
-    #                   which includes a full path to the file. If the "preserve_common_paths" parameter is set to false or left off, then the common paths of all of the ObjectFile's passed in are removed from any "path" attributes.  This should turn full paths into
-    #                   the relative paths that are required in content metadata file id nodes.  If you do not want this behavior, set "preserve_common_paths" to true.  The default is false.
-    #   :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(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
-
-    def self.special_dpg_folder?(folder)
-      SPECIAL_DPG_FOLDERS.include?(folder)
-    end
-
-    def self.find_common_path(objects)
-      all_paths = objects.flatten.map do |obj|
-        raise "File '#{obj.path}' not found" unless obj.file_exists?
-
-        obj.path # collect all of the filenames into an array
-      end
-
-      Assembly::ObjectFile.common_path(all_paths) # find common paths to all files provided if needed
-    end
-    private_class_method :find_common_path
-
-    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
-
-      case style
-      when :simple_image
-        'image'
-      when :simple_book, :book_with_pdf, :book_as_image
-        'book'
-      else
-        style.to_s
-      end
-    end
-  end # class
-end # module

data/lib/assembly-objectfile/object_fileable.rb

@@ -1,278 +0,0 @@
-# frozen_string_literal: true
-
-require 'mini_exiftool'
-require 'mime/types'
-
-module Assembly
-  # Common behaviors we need for other classes in the gem
-  module ObjectFileable
-    attr_accessor :file_attributes, :label, :path, :provider_md5, :provider_sha1, :relative_path, :mime_type_order
-
-    VALID_MIMETYPE_METHODS = %i[override exif file extension].freeze
-
-    # @param [String] path full path to the file to be worked with
-    # @param [Hash<Symbol => Object>] params options used during content metadata generation
-    # @option params [Hash<Symbol => ['yes', 'no']>] :file_attributes e.g. {:preserve=>'yes',:shelve=>'no',:publish=>'no'}, defaults pulled from mimetype
-    # @option params [String] :label a resource label (files bundlded together will just get the first file's label attribute if set)
-    # @option params [String] :provider_md5 pre-computed MD5 checksum
-    # @option params [String] :provider_sha1 pre-computed SHA1 checksum
-    # @option params [String] :relative_path if you want the file ids in the content metadata it can be set, otherwise content metadata will get the full path
-    # @option params [Array] :mime_type_order can be set to the order in which you want mimetypes to be determined
-    #                                          options are :override (from manual overide mapping if exists), :exif (from exif if exists),
-    #                                                      :extension (from file extension), and :file (from unix file system command)
-    #                                          the default is defined in the private `default_mime_type_order` method but you can override to set your own order
-    # @example
-    #   Assembly::ObjectFile.new('/input/path_to_file.tif')
-    def initialize(path, params = {})
-      @path = path
-      @label = params[:label]
-      @file_attributes = params[:file_attributes]
-      @relative_path = params[:relative_path]
-      @provider_md5 = params[:provider_md5]
-      @provider_sha1 = params[:provider_sha1]
-      @mime_type_order = params[:mime_type_order] || default_mime_type_order
-    end
-
-    # @return [String] DPG base filename, removing the extension and the '00','05', etc. placeholders
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/cy565rm7188_00_001.tif')
-    #   puts source_file.dpg_basename # "cy565rm7188_001"
-    def dpg_basename
-      file_parts = File.basename(path, ext).split('_')
-      file_parts.size == 3 ? "#{file_parts[0]}_#{file_parts[2]}" : filename_without_ext
-    end
-
-    # @return [String] DPG subfolder for the given filename, i.e. '00','05', etc.
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/cy565rm7188_00_001.tif')
-    #   puts source_file.dpg_folder # "00"
-    def dpg_folder
-      file_parts = File.basename(path, ext).split('_')
-      file_parts.size == 3 ? file_parts[1] : ''
-    end
-
-    # @return [String] base filename
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.filename # "path_to_file.tif"
-    def filename
-      File.basename(path)
-    end
-
-    # @return [String] base directory
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.dirname # "/input"
-    def dirname
-      File.dirname(path)
-    end
-
-    # @return [String] filename extension
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.ext # ".tif"
-    def ext
-      File.extname(path)
-    end
-
-    # @return [String] base filename without extension
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.filename # "path_to_file"
-    def filename_without_ext
-      File.basename(path, ext)
-    end
-
-    # @return [MiniExiftool] exif information stored as a hash and an object
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.exif # hash with exif information
-    def exif
-      @exif ||= begin
-        check_for_file
-        MiniExiftool.new(path, replace_invalid_chars: '?')
-      rescue StandardError
-        nil
-      end
-    end
-
-    # Computes md5 checksum or returns cached value
-    # @return [String] md5 checksum
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.md5 # 'XXX123XXX1243XX1243'
-    def md5
-      check_for_file unless @md5
-      @md5 ||= Digest::MD5.file(path).hexdigest
-    end
-
-    # Computes sha1 checksum or return cached value
-    # @return [String] sha1 checksum
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.sha1 # 'XXX123XXX1243XX1243'
-    def sha1
-      check_for_file unless @sha1
-      @sha1 ||= Digest::SHA1.file(path).hexdigest
-    end
-
-    # Returns mimetype information for the current file based on the ordering set in default_mime_type_order
-    #   We stop computing mimetypes as soon as we have a method that returns a value
-    # @return [String] mime type
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.txt')
-    #   puts source_file.mimetype # 'text/plain'
-    def mimetype
-      @mimetype ||= begin
-        check_for_file
-        mimetype = ''
-        mime_type_order.each do |mime_type_method|
-          mimetype = public_send("#{mime_type_method}_mimetype") if VALID_MIMETYPE_METHODS.include?(mime_type_method)
-          break if mimetype.present?
-        end
-        mimetype
-      end
-    end
-
-    # Returns mimetype information using the manual override mapping (based on a file extension lookup)
-    # @return [String] mime type for supplied file if a mapping exists for the file's extension
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.json')
-    #   puts source_file.override_mimetype # 'application/json'
-    def override_mimetype
-      @override_mimetype ||= Assembly::OVERRIDE_MIMETYPES.fetch(ext.to_sym, '')
-    end
-
-    # Returns mimetype information using the mime-types gem (based on a file extension lookup)
-    # @return [String] mime type for supplied file
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.txt')
-    #   puts source_file.extension_mimetype # 'text/plain'
-    def extension_mimetype
-      @extension_mimetype ||= begin
-        mtype = MIME::Types.type_for(path).first
-        mtype ? mtype.content_type : ''
-      end
-    end
-
-    # Returns mimetype information for the current file based on unix file system command.
-    # @return [String] mime type for supplied file
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.txt')
-    #   puts source_file.file_mimetype # 'text/plain'
-    def file_mimetype
-      @file_mimetype ||= begin
-        check_for_file
-        `file --mime-type "#{path}"`.delete("\n").split(':')[1].strip # first try and get the mimetype from the unix file command
-      end
-    end
-
-    # Returns mimetype information for the current file based on exif data (if available and not a trusted source that we'd rather get from the file system command)
-    # @return [String] mime type for supplied file
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.txt')
-    #   puts source_file.exif_mimetype # 'text/plain'
-    def exif_mimetype
-      @exif_mimetype ||= begin
-        check_for_file
-        prefer_exif = !Assembly::TRUSTED_MIMETYPES.include?(file_mimetype) # if it's not a "trusted" mimetype and there is exif data; get the mimetype from the exif
-        exif.mimetype if
-exif&.mimetype && prefer_exif
-      end
-    end
-
-    # @note Uses shell call to "file", only expected to work on unix based systems
-    # @return [String] encoding for supplied file
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.txt')
-    #   puts source_file.encoding # 'us-ascii'
-    def encoding
-      @encoding ||= begin
-        check_for_file
-        `file --mime-encoding "#{path}"`.delete("\n").split(':')[1].strip
-      end
-    end
-
-    # @return [Symbol] the type of object, could be :application (for PDF or Word, etc), :audio, :image, :message, :model, :multipart, :text or :video
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.object_type # :image
-    def object_type
-      lookup = MIME::Types[mimetype][0]
-      lookup.nil? ? :other : lookup.media_type.to_sym
-    end
-
-    # @return [Boolean] if object is an image
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.image? # true
-    def image?
-      object_type == :image
-    end
-
-    # Examines the input image for validity.  Used to determine if image is a valid and useful image.
-    # If image is not a jp2, also checks if it is jp2able?
-    # @return [Boolean] true if image is valid, false if not.
-    # @example
-    #   source_img = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_img.valid_image? # true
-    def valid_image?
-      return false unless image?
-
-      mimetype == 'image/jp2' || jp2able?
-    end
-
-    # @return [Boolean] true if image has a color profile, false if not.
-    # @example
-    #   source_img = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_img.has_color_profile? # true
-    def has_color_profile?
-      return false unless exif
-
-      exif['profiledescription'] || exif['colorspace'] ? true : false
-    end
-
-    # Examines the input image for validity to create a jp2.  Same as valid_image? but also confirms the existence of a profile description and further restricts mimetypes.
-    # It is used by the assembly robots to decide if a jp2 will be created and is also called before you create a jp2 using assembly-image.
-    # @return [Boolean] true if image should have a jp2 created, false if not.
-    # @example
-    #   source_img = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_img.jp2able? # true
-    def jp2able?
-      return false unless exif
-
-      Assembly::VALID_IMAGE_MIMETYPES.include?(mimetype)
-    end
-
-    # Returns file size information for the current file in bytes.
-    # @return [Integer] file size in bytes
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.filesize # 1345
-    def filesize
-      check_for_file
-      @filesize ||= File.size(path)
-    end
-
-    # Determines if the file exists (and is not a directory)
-    # @return [Boolean] file exists
-    # @example
-    #   source_file = Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_file.file_exists? # true
-    def file_exists?
-      @file_exists ||= (File.exist?(path) && !File.directory?(path))
-    end
-
-    private
-
-    # prive method defining default preferred ordering of how mimetypes are determined
-    def default_mime_type_order
-      %i[override exif file extension]
-    end
-
-    # private method to check for file existence before operating on it
-    def check_for_file
-      raise "input file #{path} does not exist" unless file_exists?
-    end
-  end
-end