hydra-works 0.2.0 → 0.3.0

data/lib/hydra/works/models/concerns/work_behavior.rb

@@ -0,0 +1,118 @@
+module Hydra::Works
+  # This module provides all of the Behaviors of a Hydra::Works::Work
+  #
+  # behavior:
+  #   1) Hydra::Works::Work can aggregate Hydra::Works::Work
+  #   2) Hydra::Works::Work can aggregate Hydra::Works::FileSet
+  #   3) Hydra::Works::Work can NOT aggregate Hydra::PCDM::Collection
+  #   4) Hydra::Works::Work can NOT aggregate Hydra::Works::Collection
+  #   5) Hydra::Works::Work can NOT aggregate Works::Object unless it is also a Hydra::Works::FileSet
+  #   6) Hydra::Works::Work can NOT contain PCDM::File
+  #   7) Hydra::Works::Work can NOT aggregate non-PCDM object
+  #   8) Hydra::Works::Work can NOT contain Hydra::Works::FileSet
+  #   9) Hydra::Works::Work can have descriptive metadata
+  #   10) Hydra::Works::Work can have access metadata
+  module WorkBehavior
+    extend ActiveSupport::Concern
+    extend Deprecation
+    self.deprecation_horizon = "Hydra::Works 0.4.0"
+    include Hydra::PCDM::ObjectBehavior
+
+    included do
+      type [Hydra::PCDM::Vocab::PCDMTerms.Object, Vocab::WorksTerms.Work]
+
+      alias_method :generic_works, :ordered_works
+      deprecation_deprecate :generic_works
+
+      alias_method :generic_files, :ordered_file_sets
+    end
+
+    def works
+      members.select(&:work?)
+    end
+
+    def work_ids
+      works.map(&:id)
+    end
+
+    def ordered_works
+      ordered_members.to_a.select(&:work?)
+    end
+
+    def ordered_work_ids
+      ordered_works.map(&:id)
+    end
+
+    def file_sets
+      members.select(&:file_set?)
+    end
+
+    def file_set_ids
+      file_sets.map(&:id)
+    end
+
+    def ordered_file_sets
+      ordered_members.to_a.select(&:file_set?)
+    end
+
+    def ordered_file_set_ids
+      ordered_file_sets.map(&:id)
+    end
+
+    # @return [Boolean] whether this instance is a Hydra::Works Collection.
+    def collection?
+      false
+    end
+
+    alias_method :works_collection?, :collection?
+    deprecation_deprecate :works_collection?
+
+    # @return [Boolean] whether this instance is a Hydra::Works Generic Work.
+    def work?
+      true
+    end
+
+    alias_method :works_generic_work?, :work?
+    deprecation_deprecate :works_generic_work?
+
+    # @return [Boolean] whether this instance is a Hydra::Works::FileSet.
+    def file_set?
+      false
+    end
+
+    alias_method :works_generic_file?, :file_set?
+    deprecation_deprecate :works_generic_file?
+
+    def parents
+      Deprecation.warn WorkBehavior, '`parents` is deprecated in Hydra::Works.  Please use `member_of` instead.  This has a target date for removal of 10-31-2015'
+      member_of
+    end
+
+    def in_works
+      ordered_by.select { |parent| parent.class.included_modules.include?(Hydra::Works::WorkBehavior) }.to_a
+    end
+
+    alias_method :in_generic_works, :in_works
+    deprecation_deprecate :in_generic_works
+
+    def parent_generic_works
+      Deprecation.warn WorkBehavior, '`parent_generic_works` is deprecated in Hydra::Works.  Please use `in_works` instead.  This has a target date for removal of 10-31-2015'
+      in_works
+    end
+
+    def parent_collections
+      Deprecation.warn WorkBehavior, '`parent_collections` is deprecated in Hydra::Works.  Please use `in_collections` instead.  This has a target date for removal of 10-31-2015'
+      in_collections
+    end
+
+    def child_generic_works
+      Deprecation.warn WorkBehavior, '`child_generic_works` is deprecated in Hydra::Works.  Please use `ordered_works` instead.  This has a target date for removal of 10-31-2015'
+      ordered_works
+    end
+
+    def child_generic_work_ids
+      Deprecation.warn WorkBehavior, '`child_generic_work_ids` is deprecated in Hydra::Works.  Please use `ordered_work_ids` instead.  This has a target date for removal of 10-31-2015'
+      ordered_work_ids
+    end
+  end
+end

data/lib/hydra/works/models/file_set.rb

@@ -0,0 +1,7 @@
+module Hydra::Works
+  # Holds an original file and potentially some derivatives as well as some
+  # descriptive metadata
+  class FileSet < ActiveFedora::Base
+    include Hydra::Works::FileSetBehavior
+  end
+end

data/lib/hydra/works/models/generic_file.rb

@@ -3,15 +3,15 @@ module Hydra::Works
   module GenericFile
     extend ActiveSupport::Concern
 
-    autoload :Derivatives,            'hydra/works/models/concerns/generic_file/derivatives'
-    autoload :MimeTypes,              'hydra/works/models/concerns/generic_file/mime_types'
-    autoload :ContainedFiles,         'hydra/works/models/concerns/generic_file/contained_files'
-    autoload :VersionedContent,       'hydra/works/models/concerns/generic_file/versioned_content'
-    autoload :VirusCheck,             'hydra/works/models/concerns/generic_file/virus_check'
-
-    # Base class for creating objects that behave like Hydra::Works::GenericFiles
+    # @deprecated Base class for creating objects that behave like Hydra::Works::GenericFiles
     class Base < ActiveFedora::Base
-      include Hydra::Works::GenericFileBehavior
+      extend Deprecation
+      include Hydra::Works::FileSetBehavior
+      after_initialize :deprecation_warning
+
+      def deprecation_warning
+        Deprecation.warn Base, "Hydra::Works::FileSet is deprecated and will be removed in 0.4.0. Use Hydra::Works::FileSet instead"
+      end
     end
   end
 end

data/lib/hydra/works/models/generic_work.rb

@@ -1,9 +1,20 @@
 module Hydra::Works
-  # Namespace for Modules with functionality specific to GenericWorks
-  module GenericWork
-    # Base class for creating objects that behave like Hydra::Works::GenericWorks
+  # Typically used for very generic applications that don't differntiate
+  # between specific content types. If you want a specific type of work
+  # extend Active::Fedora base and include the following:
+  #  include Hydra::Works::WorkBehavior
+  class GenericWork < ActiveFedora::Base
+    include Hydra::Works::WorkBehavior
+
+    # @deprecated Base class for creating objects that behave like Hydra::Works::GenericWorks
     class Base < ActiveFedora::Base
-      include Hydra::Works::GenericWorkBehavior
+      extend Deprecation
+      after_initialize :deprecated_warning
+      include Hydra::Works::WorkBehavior
+
+      def deprecated_warning
+        Deprecation.warn(Base, "GenericWork is deprecated and will be removed in Hydra::Works 0.4.0. Use Hydra::Works::GenericWork instead")
+      end
     end
   end
 end

data/lib/hydra/works/models/work.rb

@@ -0,0 +1,6 @@
+module Hydra::Works
+  # Namespace for Modules with functionality specific to Works
+  class Work < ActiveFedora::Base
+    include Hydra::Works::WorkBehavior
+  end
+end

data/lib/hydra/works/services/{generic_file/add_file_to_generic_file.rb → add_file_to_file_set.rb}

@@ -1,30 +1,30 @@
 module Hydra::Works
-  class AddFileToGenericFile
-    # Adds a file to the generic_file
-    # @param [Hydra::PCDM::GenericFile::Base] generic_file the file will be added to
+  class AddFileToFileSet
+    # Adds a file to the file_set
+    # @param [Hydra::PCDM::FileSet] file_set the file will be added to
     # @param [IO,File,Rack::Multipart::UploadedFile, #read] object that will be the contents. If file responds to :mime_type, :content_type, :original_name, or :original_filename, those will be called to provide metadata.
-    # @param [RDF::URI or String] type URI for the RDF.type that identifies the file's role within the generic_file
-    # @param [Boolean] update_existing whether to update an existing file if there is one. When set to true, performs a create_or_update. When set to false, always creates a new file within generic_file.files.
+    # @param [RDF::URI or String] type URI for the RDF.type that identifies the file's role within the file_set
+    # @param [Boolean] update_existing whether to update an existing file if there is one. When set to true, performs a create_or_update. When set to false, always creates a new file within file_set.files.
     # @param [Boolean] versioning whether to create new version entries (only applicable if +type+ corresponds to a versionable file)
 
-    def self.call(generic_file, file, type, update_existing: true, versioning: true)
-      fail ArgumentError, 'supplied object must be a generic file' unless generic_file.works_generic_file?
+    def self.call(file_set, file, type, update_existing: true, versioning: true)
+      fail ArgumentError, 'supplied object must be a generic file' unless file_set.file_set?
       fail ArgumentError, 'supplied file must respond to read' unless file.respond_to? :read
 
       # TODO: required as a workaround for https://github.com/projecthydra/active_fedora/pull/858
-      generic_file.save unless generic_file.persisted?
+      file_set.save unless file_set.persisted?
 
       updater_class = versioning ? VersioningUpdater : Updater
-      updater = updater_class.new(generic_file, type, update_existing)
+      updater = updater_class.new(file_set, type, update_existing)
       status = updater.update(file)
-      status ? generic_file : false
+      status ? file_set : false
     end
 
     class Updater
-      attr_reader :generic_file, :current_file
+      attr_reader :file_set, :current_file
 
-      def initialize(generic_file, type, update_existing)
-        @generic_file = generic_file
+      def initialize(file_set, type, update_existing)
+        @file_set = file_set
         @current_file = find_or_create_file(type, update_existing)
       end
 
@@ -39,8 +39,8 @@ module Hydra::Works
 
         def persist
           if current_file.new_record?
-            # persist current_file and its membership in generic_file.files container
-            generic_file.save
+            # persist current_file and its membership in file_set.files container
+            file_set.save
           else
             # we updated the content of an existing file, so we need to save the file explicitly
             current_file.save
@@ -85,16 +85,16 @@ module Hydra::Works
         # @param [true, false] update_existing when true, try to retrieve existing element before building one
         def find_or_create_file(type, update_existing)
           if type.instance_of? Symbol
-            association = generic_file.association(type)
-            fail ArgumentError, "you're attempting to add a file to a generic_file using '#{type}' association but the generic_file does not have an association called '#{type}''" unless association
+            association = file_set.association(type)
+            fail ArgumentError, "you're attempting to add a file to a file_set using '#{type}' association but the file_set does not have an association called '#{type}''" unless association
 
             current_file = association.reader if update_existing
             current_file || association.build
           else
-            current_file = generic_file.filter_files_by_type(type_to_uri(type)).first if update_existing
+            current_file = file_set.filter_files_by_type(type_to_uri(type)).first if update_existing
             unless current_file
-              generic_file.files.build
-              current_file = generic_file.files.last
+              file_set.files.build
+              current_file = file_set.files.last
               Hydra::PCDM::AddTypeToFile.call(current_file, type_to_uri(type))
             end
           end

data/lib/hydra/works/services/add_file_to_generic_file.rb

@@ -0,0 +1,8 @@
+module Hydra::Works
+  class AddFileToGenericFile
+    def self.call(*args)
+      Deprecation.warn(AddFileToGenericFile, "AddFileToGenericFile is deprecated use AddFileToFileSet. This will be removed in 0.4.0")
+      AddFileToFileSet.call(*args)
+    end
+  end
+end

data/lib/hydra/works/services/characterization_service.rb

@@ -0,0 +1,118 @@
+require 'hydra-file_characterization'
+
+module Hydra::Works
+  class CharacterizationService
+    # @param [ActiveFedora::Base] object which has properties to recieve characterization values.
+    # @param [Symbol, String, File] source for characterization to be run on.  File object, path on disk, or symbol.
+    #   A symbol should be the name of the method call to get object that responds to content? or is the content.
+    # @param [Hash] options to be passed to characterization.  parser_mapping:, parser_class:, tools:
+    def self.run(object, source = :original_file, options = {})
+      new(object, source, options).characterize
+    end
+
+    attr_accessor :object, :source, :mapping, :parser_class, :tools
+
+    def initialize(object, source, options)
+      @object = object
+      @source = source
+      @mapping, @parser_class, @tools = extract_options(options)
+    end
+
+    # Get given source into form that can be passed to Hydra::FileCharacterization
+    # Use Hydra::FileCharacterization to extract metadata (an OM Datastream)
+    # Get the terms (and their values) from the extracted metadata
+    # Assign the values of the terms to the properties of the object
+    def characterize
+      content = source_to_content
+      extracted_md = extract_metadata(content)
+      terms = parse_metadata(extracted_md)
+      store_metadata(terms)
+    end
+
+    protected
+
+      # Get value from opts hash, object, or use default
+      def extract_options(opts)
+        parser_mapping = fetch_or_respond(opts, :parser_mapping) || {}
+        parser_class = fetch_or_respond(opts, :parser_class) || FitsDatastream
+        ch12n_tool = opts.fetch(:ch12n_tool) { :fits }
+
+        [parser_mapping, parser_class, ch12n_tool]
+      end
+
+      def fetch_or_respond(opts, key)
+        opts.fetch(key) { object.send(key) if object.respond_to? key }
+      end
+
+      # @param [String,Symbol,File]
+      # @return content if source is a symbol, File if source is string
+      def source_to_content
+        if source.is_a? String
+          File.open(source)
+        elsif source.is_a? Symbol
+          s = object.send(source)
+          s.respond_to?(:content) ? s.content : s
+        else
+          source
+        end
+      end
+
+      def extract_metadata(content)
+        Hydra::FileCharacterization.characterize(content, temp_file_name, tools) do |cfg|
+          cfg[:fits] = Hydra::Derivatives.fits_path
+        end
+      end
+
+      def temp_file_name
+        m = %r{/([^/]*)$} .match(object.uri)
+        "#{m[1]}-content.tmp"
+      end
+
+      # Use OM to parse metadata
+      def parse_metadata(metadata)
+        datastream = parser_class.new
+        datastream.ng_xml = metadata if metadata.present?
+        characterization_terms(datastream)
+      end
+
+      # Get proxy terms and values from the parser
+      def characterization_terms(datastream)
+        h = {}
+        datastream.class.terminology.terms.each_pair do |key, target|
+          # a key is a proxy if its target responds to proxied_term
+          next unless target.respond_to? :proxied_term
+          begin
+            h[key] = datastream.send(key)
+          rescue NoMethodError
+            next
+          end
+        end
+        h.delete_if { |_k, v| v.empty? }
+      end
+
+      # Assign values of the instance properties from the metadata mapping :prop => val
+      def store_metadata(terms)
+        terms.each_pair do |term, value|
+          property = property_for(term)
+          next if property.nil?
+          # Array-ify the value to avoid a conditional here
+          Array(value).each { |v| append_property_value(property, v) }
+        end
+      end
+
+      # Check parser_config then self for matching term.
+      # Return property symbol or nil
+      def property_for(term)
+        if mapping.key?(term) && object.respond_to?(mapping[term])
+          mapping[term]
+        else
+          term if object.respond_to?(term)
+        end
+      end
+
+      def append_property_value(property, value)
+        value = object[property] + [value] if object.class.multiple?(property)
+        object.send("#{property}=", value)
+      end
+  end
+end

data/lib/hydra/works/services/persist_derivative.rb

@@ -0,0 +1,35 @@
+require 'hydra/derivatives'
+
+module Hydra::Works
+  class PersistDerivative < Hydra::Derivatives::PersistOutputFileService
+    ##
+    # Persists a derivative to a FileSet
+    # This Service conforms to the signature of `Hydra::Derivatives::PersistOutputFileService`.
+    # The purpose of this Service is for use as an alternative to the default Hydra::Derivatives::PersistOutputFileService.  It's necessary because the default behavior in Hydra::Derivatives assumes that you're using LDP Basic Containment. Hydra::Works::FileSets use IndirectContainment.  This Service handles that case.
+    # This service will always update existing and does not do versioning of persisted files.
+    #
+    # @param [#read] stream the derivative filestream
+    # @param [Hash] directives
+    # @option directives [FileSet] :object the FileSet object to attach to
+    # @option directives [Symbol] :label the type of derivative
+    # extract file type symbol (e.g. :thumbnail) from Hydra::Derivatives created destination_name
+    def self.call(stream, directives)
+      file = Hydra::Derivatives::IoDecorator.new(stream)
+      file.mime_type = new_mime_type(directives.fetch(:format))
+      object = directives.fetch(:object)
+      type = directives.fetch(:label)
+      Hydra::Works::AddFileToFileSet.call(object, file, type, update_existing: true, versioning: false)
+    end
+
+    def self.new_mime_type(format)
+      case format
+      when 'mp4'
+        'video/mp4' # default is application/mp4
+      when 'webm'
+        'video/webm' # default is audio/webm
+      else
+        MIME::Types.type_for(format).first.to_s
+      end
+    end
+  end
+end

data/lib/hydra/works/services/{generic_file/upload_file_to_generic_file.rb → upload_file_to_file_set.rb}

@@ -1,14 +1,14 @@
 module Hydra::Works
-  class UploadFileToGenericFile
+  class UploadFileToFileSet
     # Sets a file as the primary file (original_file) of the generic_file
-    # @param [Hydra::PCDM::GenericFile::Base] generic_file the file will be added to
+    # @param [Hydra::PCDM::FileSet] generic_file the file will be added to
     # @param [IO,File,Rack::Multipart::UploadedFile, #read] object that will be the contents. If file responds to :mime_type or :original_name, those will be called to provide technical metadata.
     # @param [Array] additional_services (ie Generating Thumbnails) to call with generic_file after adding the file as its original_file
     # @param [Boolean] update_existing whether to update an existing file if there is one. When set to true, performs a create_or_update. When set to false, always creates a new file within generic_file.files.
     # @param [Boolean] versioning whether to create new version entries (only applicable if +type+ corresponds to a versionable file)
 
     def self.call(generic_file, file, additional_services: [], update_existing: true, versioning: true)
-      Hydra::Works::AddFileToGenericFile.call(generic_file, file, :original_file, update_existing: update_existing, versioning: versioning)
+      Hydra::Works::AddFileToFileSet.call(generic_file, file, :original_file, update_existing: update_existing, versioning: versioning)
 
       # Call any additional services
       additional_services.each do |service|