hydra-works 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e1d3bbe7957645b6170f8bc00a7084fa94e670b
-  data.tar.gz: 901fcd09d4e40f5a97114e2f070ee36dffd231d6
+  metadata.gz: 95116717ae44d85ac45f788033d74e18f8144df6
+  data.tar.gz: eef16574d1817c0c984474457676997e34af7b17
 SHA512:
-  metadata.gz: d9b4ff1445474ab473dd55a97fa0de5d3e29a5879614ec0fea840929f959c9b8a8e6d424c1d7224b925863b8f157d20d8cebcce4bdf1abc1f3bb38b8f91752f2
-  data.tar.gz: b2cbefad14f81c691c5129fe0c6e7895a6f1a6b3392bd6a129490e2556b42ff4e796836de751752068d4c5c984b675dfdee7b832c2e272649cf62d5ac7d3c01f
+  metadata.gz: f7fa861ac89d69f55d7e70cf19b88feb0b0a4922eaf003dc703d29a5ba3d0bcbcefeee85888414ce19ea81ca74cc8d35442b1f407e69ce64a956657f6215b7fd
+  data.tar.gz: 1ec0c85363b2f9eebf497bb22ea26ade58ace1508620f07762b0f6d6e4f67b979a2111ab07a7fa8dbbaa61d302f29085faee89a99a2522c04faac35e4e77f4f2

data/.rubocop.yml

@@ -12,30 +12,9 @@ AllCops:
 Metrics/LineLength:
   Enabled: false
 
-Metrics/CyclomaticComplexity:
-  Exclude:
-    - lib/hydra/works/services/add_file_to_file_set.rb
-
-Metrics/PerceivedComplexity:
-  Exclude:
-    - lib/hydra/works/services/add_file_to_file_set.rb
-
-Metrics/MethodLength:
-  Exclude:
-    - lib/hydra/works/services/add_file_to_file_set.rb
-    - lib/hydra/works/models/concerns/file_set/virus_check.rb
-    - lib/hydra/works/models/characterization/fits_datastream.rb
-
 Metrics/ClassLength:
   Exclude:
-    - lib/hydra/works/models/characterization/fits_datastream.rb
-
-Metrics/AbcSize:
-  Exclude:
-    - lib/hydra/works/services/add_file_to_file_set.rb
-    - lib/hydra/works/services/full_text_extraction_service.rb
-    - lib/hydra/works/models/concerns/file_set/mime_types.rb
-    - lib/hydra/works/models/concerns/file_set/virus_check.rb
+    - lib/hydra/works/characterization/fits_datastream.rb
 
 Style/CollectionMethods:
   PreferredMethods:

data/hydra-works.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'hydra-pcdm', '>= 0.6'
+  spec.add_dependency 'hydra-pcdm', '>= 0.8'
   spec.add_dependency 'hydra-derivatives', '~> 3.0'
   spec.add_dependency 'hydra-file_characterization', '~> 0.3', '>= 0.3.3'
 

data/lib/hydra/works.rb

@@ -38,10 +38,20 @@ module Hydra
     end
 
     autoload_under 'services' do
+      autoload :VirusCheckerService
       autoload :AddFileToFileSet
       autoload :UploadFileToFileSet
       autoload :PersistDerivative
       autoload :CharacterizationService
     end
+
+    ActiveFedora::WithMetadata::DefaultMetadataClassFactory.file_metadata_schemas +=
+      [
+        Characterization::AudioSchema,
+        Characterization::BaseSchema,
+        Characterization::DocumentSchema,
+        Characterization::ImageSchema,
+        Characterization::VideoSchema
+      ]
   end
 end

data/lib/hydra/works/characterization.rb

@@ -1,10 +1,22 @@
 module Hydra::Works
   module Characterization
-    extend ActiveSupport::Concern
     extend ActiveSupport::Autoload
 
-    autoload :FitsDatastream, 'hydra/works/models/characterization/fits_datastream.rb'
-    autoload :AlreadyThereStrategy, 'hydra/works/models/characterization/already_there_strategy.rb'
+    class << self
+      attr_accessor :mapper
+      def mapper
+        @mapper ||= mapper_defaults
+      end
+
+      def mapper_defaults
+        { audio_duration: :duration, audio_sample_rate: :sample_rate, exif_tool_version: :exif_version,
+          file_author: :creator, file_language: :language, file_mime_type: :has_mime_type,
+          video_audio_sample_rate: :sample_rate, video_duration: :duration, video_height: :height,
+          video_sample_rate: :sample_rate, video_width: :width }
+      end
+    end
+
+    autoload :FitsDatastream, 'hydra/works/characterization/fits_datastream.rb'
 
     autoload_under 'schema' do
       autoload :AudioSchema
@@ -13,19 +25,5 @@ module Hydra::Works
       autoload :ImageSchema
       autoload :VideoSchema
     end
-
-    autoload :Base, 'hydra/works/models/concerns/file_set/characterization/base.rb'
-    autoload :Image, 'hydra/works/models/concerns/file_set/characterization/image.rb'
-    autoload :Document, 'hydra/works/models/concerns/file_set/characterization/document.rb'
-    autoload :Video, 'hydra/works/models/concerns/file_set/characterization/video.rb'
-    autoload :Audio, 'hydra/works/models/concerns/file_set/characterization/audio.rb'
-
-    included do
-      include Base
-      include Image
-      include Audio
-      include Video
-      include Document
-    end
   end
 end

data/lib/hydra/works/{models/characterization → characterization}/fits_datastream.rb

@@ -148,11 +148,9 @@ module Hydra::Works::Characterization
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.fits(xmlns: 'http://hul.harvard.edu/ois/xml/ns/fits/fits_output',
                  'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
-                 'xsi:schemaLocation' =>
-      "http://hul.harvard.edu/ois/xml/ns/fits/fits_output
-      http://hul.harvard.edu/ois/xml/xsd/fits/fits_output.xsd",
-                 version: '0.6.0',
-                 timestamp: '1/25/12 11:04 AM') do
+                 'xsi:schemaLocation' => "http://hul.harvard.edu/ois/xml/ns/fits/fits_output
+                 http://hul.harvard.edu/ois/xml/xsd/fits/fits_output.xsd",
+                 version: '0.6.0', timestamp: '1/25/12 11:04 AM') do
           xml.identification { xml.identity(toolname: 'FITS') }
         end
       end

data/lib/hydra/works/characterization/schema/base_schema.rb

@@ -1,17 +1,13 @@
 module Hydra::Works::Characterization
   class BaseSchema < ActiveTriples::Schema
-    property :filename, predicate: RDF::Vocab::EBUCore.filename, multiple: false
     property :format_label, predicate: RDF::Vocab::PREMIS.hasFormatName
     property :file_size, predicate: RDF::Vocab::EBUCore.fileSize
     property :well_formed, predicate: RDF::URI.new("http://projecthydra.org/ns/fits/wellFormed")
     property :valid, predicate: RDF::URI.new("http://projecthydra.org/ns/fits/valid")
     property :date_created, predicate: RDF::Vocab::EBUCore.dateCreated
-    property :last_modified, predicate: RDF::Vocab::EBUCore.dateModified
     property :fits_version, predicate: RDF::Vocab::PREMIS.hasCreatingApplicationVersion
     property :exif_version, predicate: RDF::Vocab::EXIF.exifVersion
     property :original_checksum, predicate: RDF::Vocab::NFO.hashValue
-    property :mime_type, predicate: RDF::Vocab::EBUCore.hasMimeType, multiple: false do |index|
-      index.as :stored_searchable
-    end
+    property :mime_type, predicate: RDF::Vocab::EBUCore.hasMimeType
   end
 end

data/lib/hydra/works/characterization/schema/image_schema.rb

@@ -1,15 +1,13 @@
 module Hydra::Works::Characterization
   class ImageSchema < ActiveTriples::Schema
-    property :byte_order, predicate: RDF::URI('http://sweet.jpl.nasa.gov/2.2/reprDataFormat.owl#byteOrder'), multiple: false
-    property :compression, predicate: RDF::URI('http://projecthydra.org/ns/mix/compressionScheme'), multiple: false
+    property :byte_order, predicate: RDF::URI('http://sweet.jpl.nasa.gov/2.2/reprDataFormat.owl#byteOrder')
+    property :compression, predicate: RDF::URI('http://projecthydra.org/ns/mix/compressionScheme')
     property :height, predicate: RDF::Vocab::EBUCore.height
     property :width, predicate: RDF::Vocab::EBUCore.width
-    # property :width, predicate: RDF::Vocab::EXIF.imageWidth, multiple: false
-    # property :height, predicate: RDF::Vocab::EXIF.imageLength, multiple: false
-    property :color_space, predicate: RDF::Vocab::EXIF.colorSpace, multiple: false
+    property :color_space, predicate: RDF::Vocab::EXIF.colorSpace
     property :profile_name, predicate: RDF::URI('http://projecthydra.org/ns/mix/colorProfileName')
     property :profile_version, predicate: RDF::URI('http://projecthydra.org/ns/mix/colorProfileVersion')
-    property :orientation, predicate: RDF::Vocab::EXIF.orientation, multiple: false
+    property :orientation, predicate: RDF::Vocab::EXIF.orientation
     property :color_map, predicate: RDF::URI('http://projecthydra.org/ns/mix/colorMap')
     property :image_producer, predicate: RDF::Vocab::MARCRelators.pht
     property :capture_device, predicate: RDF::Vocab::EXIF.model

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

@@ -4,49 +4,12 @@ module Hydra::Works
 
     included do
       validate :detect_viruses
-    end
-
-    # Default behavior is to raise a validation error and halt the save if a virus is found
-    def detect_viruses
-      return unless original_file && original_file.new_record?
-
-      path = original_file.is_a?(String) ? original_file : local_path_for_file(original_file)
-      unless defined?(ClamAV)
-        warning "Virus checking disabled, #{path} not checked"
-        return
-      end
-
-      scan_result = ClamAV.instance.scanfile(path)
-      if scan_result == 0
-        true
-      else
-        virus_message = "A virus was found in #{path}: #{scan_result}"
-        warning(virus_message)
-        errors.add(:base, virus_message)
+      def detect_viruses
+        return true unless original_file && original_file.new_record? # We have a new file to check
+        return true unless VirusCheckerService.file_has_virus?(original_file)
+        errors.add(:base, "Failed to verify uploaded file is not a virus")
         false
       end
     end
-
-    private
-
-      def warning(msg)
-        ActiveFedora::Base.logger.warn msg if ActiveFedora::Base.logger
-      end
-
-      # Returns a path for reading the content of +file+
-      # @param [File] file object to retrieve a path for
-      def local_path_for_file(file)
-        if file.respond_to?(:path)
-          file.path
-        else
-          Tempfile.open('') do |t|
-            t.binmode
-            t.write(file.content.read)
-            file.content.rewind
-            t.close
-            t.path
-          end
-        end
-      end
   end
 end

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

@@ -80,18 +80,25 @@ 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 = 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
+            find_or_create_file_for_symbol(type, update_existing)
           else
-            current_file = file_set.filter_files_by_type(type_to_uri(type)).first if update_existing
-            unless current_file
-              file_set.files.build
-              current_file = file_set.files.last
-              Hydra::PCDM::AddTypeToFile.call(current_file, type_to_uri(type))
-            end
+            find_or_create_file_for_rdf_uri(type, update_existing)
+          end
+        end
+
+        def find_or_create_file_for_symbol(type, update_existing)
+          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
+        end
+
+        def find_or_create_file_for_rdf_uri(type, update_existing)
+          current_file = file_set.filter_files_by_type(type_to_uri(type)).first if update_existing
+          unless current_file
+            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/characterization_service.rb

@@ -2,20 +2,22 @@ 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 [Hydra::PCDM::File] object which has properties to recieve characterization values.
+    # @param [String, File] source for characterization to be run on.  File object or path on disk.
+    #   If none is provided, it will assume the binary content already present on the object.
     # @param [Hash] options to be passed to characterization.  parser_mapping:, parser_class:, tools:
-    def self.run(object, source = :original_file, options = {})
+    def self.run(object, source = nil, 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)
+      @object       = object
+      @source       = source
+      @mapping      = options.fetch(:parser_mapping, Hydra::Works::Characterization.mapper)
+      @parser_class = options.fetch(:parser_class, Hydra::Works::Characterization::FitsDatastream)
+      @tools        = options.fetch(:ch12n_tool, :fits)
     end
 
     # Get given source into form that can be passed to Hydra::FileCharacterization
@@ -31,41 +33,27 @@ module Hydra::Works
 
     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
+      # @return content of object if source is nil; otherwise, return a File or the source
       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
+        return object.content if source.nil?
+        return File.open(source).read if source.is_a? String
+        source.read
       end
 
       def extract_metadata(content)
-        Hydra::FileCharacterization.characterize(content, temp_file_name, tools) do |cfg|
+        Hydra::FileCharacterization.characterize(content, 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"
+      # Determine the filename to send to Hydra::FileCharacterization. If no source is present,
+      # use the name of the file from the object; otherwise, use the supplied source.
+      def file_name
+        if source
+          source.is_a?(File) ? File.basename(source.path) : File.basename(source)
+        else
+          object.original_name.nil? ? "original_file" : object.original_name
+        end
       end
 
       # Use OM to parse metadata
@@ -111,8 +99,8 @@ module Hydra::Works
       end
 
       def append_property_value(property, value)
-        value = object[property] + [value] if object.class.multiple?(property)
-        object.send("#{property}=", value)
+        value = object.send(property) + [value]
+        object.send("#{property}=", value.uniq)
       end
   end
 end

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

@@ -0,0 +1,73 @@
+module Hydra::Works
+  # Responsible for checking if the given file is a virus. Coordinates
+  # with the underlying system virus scanner.
+  class VirusCheckerService
+    attr_accessor :original_file, :system_virus_scanner
+
+    # @api public
+    # @param original_file [String, #path]
+    # @return true if a virus was detected
+    # @return true if anti-virus was not able to run
+    # @return false if the file was scanned and no viruses were found
+    def self.file_has_virus?(original_file)
+      new(original_file).file_has_virus?
+    end
+
+    def initialize(original_file, system_virus_scanner = default_system_virus_scanner)
+      self.original_file = original_file
+      self.system_virus_scanner = system_virus_scanner
+    end
+
+    # Default behavior is to raise a validation error and halt the save if a virus is found
+    def file_has_virus?
+      path = original_file.is_a?(String) ? original_file : local_path_for_file(original_file)
+      scan_result = system_virus_scanner.call(path)
+      handle_virus_scan_results(path, scan_result)
+    end
+
+    private
+
+      # Stubbing out the behavior of "The Clam" was growing into a rather nasty
+      # challenge. So instead I'm injecting a system scanner. This allows me to
+      # now test the default system scanner in isolation from the general response
+      # to a system scan.
+      def default_system_virus_scanner
+        if defined?(ClamAV)
+          ClamAV.instance.method(:scanfile)
+        else
+          lambda do |_path|
+            :no_anti_virus_was_run
+          end
+        end
+      end
+
+      def handle_virus_scan_results(path, scan_result)
+        case scan_result
+        when 0 then return false
+        when 1
+          warning("A virus was found in #{path}: #{scan_result}")
+          true
+        else
+          warning "Virus checking disabled, #{path} not checked"
+          true
+        end
+      end
+
+      def warning(msg)
+        ActiveFedora::Base.logger.warn msg if ActiveFedora::Base.logger
+      end
+
+      # Returns a path for reading the content of +file+
+      # @param [File] file object to retrieve a path for
+      def local_path_for_file(file)
+        return file.path if file.respond_to?(:path)
+        Tempfile.open('') do |t|
+          t.binmode
+          t.write(file.content.read)
+          file.content.rewind
+          t.close
+          t.path
+        end
+      end
+  end
+end

data/lib/hydra/works/version.rb

@@ -1,5 +1,5 @@
 module Hydra
   module Works
-    VERSION = '0.9.0'.freeze
+    VERSION = '0.10.0'.freeze
   end
 end

data/spec/hydra/works/characterization_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Hydra::Works::Characterization do
+  let(:file) { Hydra::PCDM::File.new }
+
+  describe "properties" do
+    subject { file }
+    context "with inhereited terms from ActiveFedora" do
+      it { is_expected.to respond_to(:label) }
+      it { is_expected.to respond_to(:file_name) }
+      it { is_expected.to respond_to(:file_size) }
+      it { is_expected.to respond_to(:date_created) }
+      it { is_expected.to respond_to(:has_mime_type) }
+      it { is_expected.to respond_to(:date_modified) }
+      it { is_expected.to respond_to(:byte_order) }
+    end
+    context "with Base schema" do
+      it { is_expected.to respond_to(:format_label) }
+      it { is_expected.to respond_to(:file_size) }
+      it { is_expected.to respond_to(:well_formed) }
+      it { is_expected.to respond_to(:valid) }
+      it { is_expected.to respond_to(:date_created) }
+      it { is_expected.to respond_to(:fits_version) }
+      it { is_expected.to respond_to(:exif_version) }
+      it { is_expected.to respond_to(:original_checksum) }
+      it { is_expected.to respond_to(:mime_type) }
+    end
+    context "with Image schema" do
+      it { is_expected.to respond_to(:byte_order) }
+      it { is_expected.to respond_to(:compression) }
+      it { is_expected.to respond_to(:height) }
+      it { is_expected.to respond_to(:width) }
+      it { is_expected.to respond_to(:color_space) }
+      it { is_expected.to respond_to(:profile_name) }
+      it { is_expected.to respond_to(:profile_version) }
+      it { is_expected.to respond_to(:orientation) }
+      it { is_expected.to respond_to(:color_map) }
+      it { is_expected.to respond_to(:image_producer) }
+      it { is_expected.to respond_to(:capture_device) }
+      it { is_expected.to respond_to(:scanning_software) }
+      it { is_expected.to respond_to(:gps_timestamp) }
+      it { is_expected.to respond_to(:latitude) }
+      it { is_expected.to respond_to(:longitude) }
+    end
+    context "with Document schema" do
+      it { is_expected.to respond_to(:file_title) }
+      it { is_expected.to respond_to(:creator) }
+      it { is_expected.to respond_to(:page_count) }
+      it { is_expected.to respond_to(:language) }
+      it { is_expected.to respond_to(:word_count) }
+      it { is_expected.to respond_to(:character_count) }
+      it { is_expected.to respond_to(:line_count) }
+      it { is_expected.to respond_to(:character_set) }
+      it { is_expected.to respond_to(:markup_basis) }
+      it { is_expected.to respond_to(:markup_language) }
+      it { is_expected.to respond_to(:paragraph_count) }
+      it { is_expected.to respond_to(:table_count) }
+      it { is_expected.to respond_to(:graphics_count) }
+    end
+    context "with Video schema" do
+      it { is_expected.to respond_to(:height) }
+      it { is_expected.to respond_to(:width) }
+      it { is_expected.to respond_to(:frame_rate) }
+      it { is_expected.to respond_to(:duration) }
+      it { is_expected.to respond_to(:sample_rate) }
+    end
+    context "with Audio schema" do
+      it { is_expected.to respond_to(:bit_depth) }
+      it { is_expected.to respond_to(:channels) }
+      it { is_expected.to respond_to(:data_format) }
+      it { is_expected.to respond_to(:frame_rate) }
+      it { is_expected.to respond_to(:duration) }
+      it { is_expected.to respond_to(:sample_rate) }
+      it { is_expected.to respond_to(:offset) }
+    end
+  end
+
+  describe "::mapper" do
+    let(:mapper_keys) do
+      [
+        :audio_duration,
+        :audio_sample_rate,
+        :exif_tool_version,
+        :file_author,
+        :file_language,
+        :file_mime_type,
+        :video_audio_sample_rate,
+        :video_duration,
+        :video_height,
+        :video_sample_rate,
+        :video_width
+      ]
+    end
+    subject { described_class.mapper.keys }
+    it { is_expected.to eq(mapper_keys) }
+  end
+end

data/spec/hydra/works/models/concerns/file_set/virus_check_spec.rb

@@ -2,37 +2,23 @@ require 'spec_helper'
 
 describe Hydra::Works::VirusCheck do
   context "with ClamAV" do
+    subject { FileWithVirusCheck.new }
+    let(:file) { Hydra::PCDM::File.new { |f| f.content = File.new(File.join(fixture_path, 'sample-file.pdf')) } }
+
     before do
       class FileWithVirusCheck < ActiveFedora::Base
         include Hydra::Works::FileSetBehavior
         include Hydra::Works::VirusCheck
       end
-      class ClamAV
-        def self.instance
-          @instance ||= ClamAV.new
-        end
-
-        def scanfile(path)
-          puts "scanfile: #{path}"
-        end
-      end
+      allow(subject).to receive(:original_file) { file }
     end
     after do
-      Object.send(:remove_const, :ClamAV)
       Object.send(:remove_const, :FileWithVirusCheck)
     end
 
-    subject { FileWithVirusCheck.new }
-    let(:file) { Hydra::PCDM::File.new { |f| f.content = File.new(File.join(fixture_path, 'sample-file.pdf')) } }
-
-    before do
-      allow(subject).to receive(:original_file) { file }
-      allow(subject).to receive(:warn) # suppress virus warning messages
-    end
-
     context 'with an infected file' do
       before do
-        expect(ClamAV.instance).to receive(:scanfile).and_return(1)
+        expect(Hydra::Works::VirusCheckerService).to receive(:file_has_virus?).and_return(true)
       end
       it 'fails to save' do
         expect(subject.save).to eq false
@@ -44,56 +30,12 @@ describe Hydra::Works::VirusCheck do
 
     context 'with a clean file' do
       before do
-        expect(ClamAV.instance).to receive(:scanfile).and_return(0)
       end
 
       it 'does not detect viruses' do
-        expect(subject.detect_viruses).to eq true
-      end
-    end
-
-    context 'with a file that responds to :path' do
-      before do
-        allow(file).to receive(:path).and_return('/tmp/file.pdf')
-      end
-
-      it 'gets the filename from :path' do
-        expect(subject.send(:local_path_for_file, file)).to eq('/tmp/file.pdf')
-      end
-    end
-
-    context 'original file does not respond to path' do
-      before do
-        allow(file).to receive(:respond_to?).and_call_original
-        allow(file).to receive(:respond_to?).with(:path).and_return(false)
-      end
-
-      it 'reads the content of the original_file' do
-        expect(file.content).to receive(:read)
+        expect(Hydra::Works::VirusCheckerService).to receive(:file_has_virus?).and_return(false)
         subject.detect_viruses
       end
     end
   end
-
-  context "Without ClamAV" do
-    before do
-      class FileWithVirusCheck < ActiveFedora::Base
-        include Hydra::Works::FileSetBehavior
-        include Hydra::Works::VirusCheck
-      end
-      Object.send(:remove_const, :ClamAV) if defined?(ClamAV)
-    end
-
-    subject { FileWithVirusCheck.new }
-    let(:file) { Hydra::PCDM::File.new { |f| f.content = File.new(File.join(fixture_path, 'sample-file.pdf')) } }
-
-    before do
-      allow(subject).to receive(:original_file) { file }
-    end
-
-    it 'warns if ClamAV is not defined' do
-      expect(subject).to receive(:warning) # .with("Virus checking disabled, sample-file.pdf not checked")
-      expect(subject.detect_viruses).to eq nil
-    end
-  end
 end

data/spec/hydra/works/services/characterization_service_spec.rb

@@ -2,37 +2,31 @@ require 'spec_helper'
 require 'support/file_set_helper'
 
 describe Hydra::Works::CharacterizationService do
-  let(:demo_class) do
-    Class.new(Hydra::Works::FileSet) do
-      include Hydra::Works::Characterization
-    end
-  end
-
   describe "integration test for characterizing from path on disk." do
-    let(:filename)           { 'sample-file.pdf' }
-    let(:path_on_disk)       { File.join(fixture_path, filename) }
-    let(:file_set) { demo_class.new(id: 'inte/gr/at/ion') }
+    let(:filename)     { 'sample-file.pdf' }
+    let(:path_on_disk) { File.join(fixture_path, filename) }
+    let(:file)         { Hydra::PCDM::File.new }
 
     before do
       skip 'external tools not installed for CI environment' if ENV['CI']
-      described_class.run(file_set, path_on_disk)
+      described_class.run(file, path_on_disk)
     end
 
-    it 'successfully sets and persists the property values' do
-      expect(file_set.file_size).to eq(["7618"])
-      expect(file_set.file_title).to eq(["sample-file"])
-      expect(file_set.page_count).to eq(["1"])
+    it 'successfully sets the property values' do
+      expect(file.file_size).to eq(["7618"])
+      expect(file.file_title).to eq(["sample-file"])
+      expect(file.page_count).to eq(["1"])
       # Persist and reload from persistence layer
-      expect(file_set.save).to be true
-      expect(file_set.reload).to be file_set
+      expect(file.save).to be nil
+      expect(file.reload).to be nil
       # Re-check property values
-      expect(file_set.file_size).to eq(["7618"])
-      expect(file_set.file_title).to eq(["sample-file"])
-      expect(file_set.page_count).to eq(["1"])
+      expect(file.file_size).to eq(["7618"])
+      expect(file.file_title).to eq(["sample-file"])
+      expect(file.page_count).to eq(["1"])
     end
   end
 
-  describe "handling symbols, strings, and files as sources" do
+  describe "handling strings, files, and Hydra::PCDM::File as sources" do
     # Stub Hydra::FileCharacterization.characterize
     let(:characterization)   { class_double("Hydra::FileCharacterization").as_stubbed_const }
     let(:fits_filename)      { 'fits_0.8.5_pdf.xml' }
@@ -40,131 +34,126 @@ describe Hydra::Works::CharacterizationService do
     let(:filename)           { 'sample-file.pdf' }
     let(:file_content)       { IO.read(File.join(fixture_path, filename)) }
     let(:file)               { Hydra::PCDM::File.new { |f| f.content = file_content } }
-    let(:file_set) { demo_class.new(id: 'demo/ch/12/on') }
 
     before do
-      mock_add_file_to_file_set(file_set, file)
       allow(characterization).to receive(:characterize).and_return(fits_response)
     end
 
-    context "using default Symbol as the source." do
-      it 'calls the corresponding method of the object.' do
-        expect(file_set).to receive(:original_file)
-        described_class.run(file_set)
+    context "with the object as the source" do
+      it 'calls the content method of the object.' do
+        expect(file).to receive(:content)
+        described_class.run(file)
       end
 
-      it 'passes the content to characterization.' do
-        expect(Hydra::FileCharacterization).to receive(:characterize).with(file_content, any_args)
-        described_class.run(file_set)
+      context "when original_name is not present" do
+        it 'passes the content to characterization.' do
+          expect(Hydra::FileCharacterization).to receive(:characterize).with(file_content, "original_file", :fits)
+          described_class.run(file)
+        end
+      end
+
+      context "when original_name is present" do
+        before { allow(file).to receive(:original_name).and_return(filename) }
+        it 'passes the content to characterization.' do
+          expect(Hydra::FileCharacterization).to receive(:characterize).with(file_content, filename, :fits)
+          described_class.run(file)
+        end
       end
     end
 
     context "using a string path as the source." do
       it 'passes a file with the string as a path to FileCharacterization.' do
         path_on_disk = File.join(fixture_path, filename)
-        expect(Hydra::FileCharacterization).to receive(:characterize).with(kind_of(File), any_args)
-        described_class.run(file_set, path_on_disk)
+        expect(Hydra::FileCharacterization).to receive(:characterize).with(file_content, filename, :fits)
+        described_class.run(file, path_on_disk)
       end
     end
 
     context "using a File instance as the source." do
       it 'passes the File to FileCharacterization.' do
         file_inst = File.new(File.join(fixture_path, filename))
-        expect(Hydra::FileCharacterization).to receive(:characterize).with(file_inst, any_args)
-        described_class.run(file_set, file_inst)
+        expect(Hydra::FileCharacterization).to receive(:characterize).with(file_content, filename, :fits)
+        described_class.run(file, file_inst)
       end
     end
   end
 
   context "passing an object that does not have matching properties" do
-    # Stub Hydra::FileCharacterization.characterize
+    let!(:current_schemas) { ActiveFedora::WithMetadata::DefaultMetadataClassFactory.file_metadata_schemas }
+
     let(:characterization) { class_double("Hydra::FileCharacterization").as_stubbed_const }
-    let(:bland_class) do
-      Class.new(Hydra::Works::FileSet) { include Hydra::Works::Characterization }
-    end
-    let(:fits_filename)      { 'fits_0.8.5_pdf.xml' }
-    let(:fits_response)      { IO.read(File.join(fixture_path, fits_filename)) }
-    let(:file_content)       { 'dummy content' }
-    let(:file)               { Hydra::PCDM::File.new { |f| f.content = file_content } }
-    let(:file_set) { bland_class.new(id: 'base/ch/12/on') }
+    let(:fits_filename)    { 'fits_0.8.5_pdf.xml' }
+    let(:fits_response)    { IO.read(File.join(fixture_path, fits_filename)) }
+    let(:file_content)     { 'dummy content' }
+    let(:file)             { Hydra::PCDM::File.new { |f| f.content = file_content } }
 
     before do
-      mock_add_file_to_file_set(file_set, file)
+      ActiveFedora::WithMetadata::DefaultMetadataClassFactory.file_metadata_schemas = [ActiveFedora::WithMetadata::DefaultSchema]
       allow(characterization).to receive(:characterize).and_return(fits_response)
     end
+    after do
+      ActiveFedora::WithMetadata::DefaultMetadataClassFactory.file_metadata_schemas = [current_schemas]
+    end
 
     it 'does not explode with an error' do
-      expect { described_class.run(file_set) }.not_to raise_error
+      expect { described_class.run(file) }.not_to raise_error
     end
   end
 
   describe 'assigned properties.' do
     # Stub Hydra::FileCharacterization.characterize
     let(:characterization) { class_double("Hydra::FileCharacterization").as_stubbed_const }
-    let(:file)               { Hydra::PCDM::File.new }
-    let(:file_set) { demo_class.new(id: 'prop/er/ti/es') }
+    let(:file)             { Hydra::PCDM::File.new }
 
     before do
-      mock_add_file_to_file_set(file_set, file)
+      allow(file).to receive(:content).and_return("mocked content")
+      allow(characterization).to receive(:characterize).and_return(fits_response)
+      described_class.run(file)
     end
 
     context 'using document metadata' do
-      let(:fits_filename)      { 'fits_0.8.5_pdf.xml' }
-      let(:fits_response)      { IO.read(File.join(fixture_path, fits_filename)) }
-
-      before do
-        allow(characterization).to receive(:characterize).and_return(fits_response)
-        described_class.run(file_set)
-      end
+      let(:fits_filename) { 'fits_0.8.5_pdf.xml' }
+      let(:fits_response) { IO.read(File.join(fixture_path, fits_filename)) }
 
       it 'assigns expected values to document properties.' do
-        expect(file_set.file_title).to eq(["sample-file"])
-        expect(file_set.page_count).to eq(["1"])
+        expect(file.file_title).to eq(["sample-file"])
+        expect(file.page_count).to eq(["1"])
       end
     end
 
     context 'using image metadata' do
-      let(:fits_filename)      { 'fits_0.8.5_jp2.xml' }
-      let(:fits_response)      { IO.read(File.join(fixture_path, fits_filename)) }
-      before do
-        allow(characterization).to receive(:characterize).and_return(fits_response)
-        described_class.run(file_set)
-      end
+      let(:fits_filename) { 'fits_0.8.5_jp2.xml' }
+      let(:fits_response) { IO.read(File.join(fixture_path, fits_filename)) }
+
       it 'assigns expected values to image properties.' do
-        expect(file_set.file_size).to eq(["11043"])
-        expect(file_set.byte_order).to eq("big endian")
-        expect(file_set.compression).to eq("JPEG 2000")
-        expect(file_set.width).to eq(["512"])
-        expect(file_set.height).to eq(["465"])
-        expect(file_set.color_space).to eq("sRGB")
+        expect(file.file_size).to eq(["11043"])
+        expect(file.byte_order).to eq(["big endian"])
+        expect(file.compression).to eq(["JPEG 2000 Lossless", "JPEG 2000"])
+        expect(file.width).to eq(["512"])
+        expect(file.height).to eq(["465"])
+        expect(file.color_space).to eq(["sRGB"])
       end
     end
     context 'using video metadata' do
-      let(:fits_filename)      { 'fits_0.8.5_avi.xml' }
-      let(:fits_response)      { IO.read(File.join(fixture_path, fits_filename)) }
-      before do
-        allow(characterization).to receive(:characterize).and_return(fits_response)
-        described_class.run(file_set)
-      end
+      let(:fits_filename) { 'fits_0.8.5_avi.xml' }
+      let(:fits_response) { IO.read(File.join(fixture_path, fits_filename)) }
+
       it 'assigns expected values to video properties.' do
-        expect(file_set.height).to eq(["264"])
-        expect(file_set.width).to eq(["356"])
-        expect(file_set.duration).to eq(["14.10 s"])
-        expect(file_set.frame_rate).to eq(["10"])
-        expect(file_set.sample_rate).to eq(["11025"])
+        expect(file.height).to eq(["264"])
+        expect(file.width).to eq(["356"])
+        expect(file.duration).to eq(["14.10 s"])
+        expect(file.frame_rate).to eq(["10"])
+        expect(file.sample_rate).to eq(["11025"])
       end
     end
     context 'using audio metadata' do
-      let(:fits_filename)      { 'fits_0.8.5_mp3.xml' }
-      let(:fits_response)      { IO.read(File.join(fixture_path, fits_filename)) }
-      before do
-        allow(characterization).to receive(:characterize).and_return(fits_response)
-        described_class.run(file_set)
-      end
+      let(:fits_filename) { 'fits_0.8.5_mp3.xml' }
+      let(:fits_response) { IO.read(File.join(fixture_path, fits_filename)) }
+
       it 'assigns expected values to audio properties.' do
-        expect(file_set.mime_type).to eq("audio/mpeg")
-        expect(file_set.duration).to eq(["0:0:15:261"])
-        expect(file_set.sample_rate).to eq(["44100"])
+        expect(file.has_mime_type).to eq(["audio/mpeg"])
+        expect(file.duration).to eq(["0:0:15:261"])
+        expect(file.sample_rate).to eq(["44100"])
       end
     end
   end
@@ -172,27 +161,23 @@ describe Hydra::Works::CharacterizationService do
   describe 'assigned properties from fits 0.6.2' do
     # Stub Hydra::FileCharacterization.characterize
     let(:characterization) { class_double("Hydra::FileCharacterization").as_stubbed_const }
-    let(:file)               { Hydra::PCDM::File.new }
-    let(:file_set) { demo_class.new(id: 'old/pr/op/es') }
-
-    before do
-      mock_add_file_to_file_set(file_set, file)
-    end
+    let(:file)             { Hydra::PCDM::File.new }
 
     context 'using image metadata' do
-      let(:fits_filename)      { 'fits_0.6.2_jpg.xml' }
-      let(:fits_response)      { IO.read(File.join(fixture_path, fits_filename)) }
+      let(:fits_filename) { 'fits_0.6.2_jpg.xml' }
+      let(:fits_response) { IO.read(File.join(fixture_path, fits_filename)) }
       before do
+        allow(file).to receive(:content).and_return("mocked content")
         allow(characterization).to receive(:characterize).and_return(fits_response)
-        described_class.run(file_set)
+        described_class.run(file)
       end
       it 'assigns expected values to image properties.' do
-        expect(file_set.file_size).to eq(["57639"])
-        expect(file_set.byte_order).to eq("big endian")
-        expect(file_set.compression).to eq("JPEG (old-style)")
-        expect(file_set.width).to eq(["600"])
-        expect(file_set.height).to eq(["381"])
-        expect(file_set.color_space).to eq("YCbCr")
+        expect(file.file_size).to eq(["57639"])
+        expect(file.byte_order).to eq(["big endian"])
+        expect(file.compression).to eq(["JPEG (old-style)"])
+        expect(file.width).to eq(["600"])
+        expect(file.height).to eq(["381"])
+        expect(file.color_space).to eq(["YCbCr"])
       end
     end
   end

data/spec/hydra/works/services/virus_checker_service_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Hydra::Works::VirusCheckerService do
+  let(:system_virus_scanner) { double(call: nil) }
+  let(:file) { Hydra::PCDM::File.new { |f| f.content = File.new(File.join(fixture_path, 'sample-file.pdf')) } }
+  let(:virus_checker) { described_class.new(file, system_virus_scanner) }
+
+  context '.file_has_virus?' do
+    it 'is a convenience method' do
+      mock_object = double(file_has_virus?: true)
+      allow(described_class).to receive(:new).and_return(mock_object)
+      described_class.file_has_virus?(file)
+      expect(mock_object).to have_received(:file_has_virus?)
+    end
+  end
+
+  context 'with a system virus scanner that did not run' do
+    let(:virus_checker) { described_class.new(file) }
+    it 'will return false and set a system warning' do
+      expect(defined?(ClamAV)).to eq(nil) # A bit of a sanity test to make sure the default behaves
+      allow(file).to receive(:path).and_return('/tmp/file.pdf')
+      expect(virus_checker).to receive(:warning).with(kind_of(String))
+      expect(virus_checker.file_has_virus?).to eq(true)
+    end
+  end
+
+  context 'with an infected file' do
+    context 'that responds to :path' do
+      it 'will return false' do
+        expect(system_virus_scanner).to receive(:call).with('/tmp/file.pdf').and_return(1)
+        allow(file).to receive(:path).and_return('/tmp/file.pdf')
+        expect(virus_checker.file_has_virus?).to eq(true)
+      end
+    end
+    context 'that does not respond to :path' do
+      it 'will return false' do
+        expect(system_virus_scanner).to receive(:call).with(kind_of(String)).and_return(1)
+        allow(file).to receive(:respond_to?).and_call_original
+        allow(file).to receive(:respond_to?).with(:path).and_return(false)
+        expect(virus_checker.file_has_virus?).to eq(true)
+      end
+    end
+  end
+
+  context 'with a clean file' do
+    context 'that responds to :path' do
+      it 'will return true' do
+        expect(system_virus_scanner).to receive(:call).with('/tmp/file.pdf').and_return(0)
+        allow(file).to receive(:path).and_return('/tmp/file.pdf')
+        expect(virus_checker.file_has_virus?).to eq(false)
+      end
+    end
+    context 'that does not respond to :path' do
+      it 'will return true' do
+        expect(system_virus_scanner).to receive(:call).with(kind_of(String)).and_return(0)
+        allow(file).to receive(:respond_to?).and_call_original
+        allow(file).to receive(:respond_to?).with(:path).and_return(false)
+        expect(virus_checker.file_has_virus?).to eq(false)
+      end
+    end
+  end
+
+  context '#default_system_virus_scanner' do
+    let(:virus_checker) { described_class.new(file) }
+    let(:system_virus_scanner) { virus_checker.send(:default_system_virus_scanner) }
+    it 'is callable' do
+      expect(system_virus_scanner).to respond_to(:call)
+    end
+    context 'when called and ClamAV is NOT defined' do
+      it 'will warn and return :no_anti_virus_was_run if ClamAV is not defined' do
+        expect(system_virus_scanner.call('/tmp/path')).to eq(:no_anti_virus_was_run)
+      end
+    end
+    context 'when called and ClamAV is defined' do
+      before do
+        class ClamAV
+          def self.instance
+            @instance ||= ClamAV.new
+          end
+
+          def scanfile(path)
+            puts "scanfile: #{path}"
+          end
+        end
+      end
+      after do
+        Object.send(:remove_const, :ClamAV)
+      end
+      it "will call the Clam's scanfile" do
+        expect(ClamAV.instance).to receive(:scanfile).with('/tmp/path')
+        system_virus_scanner.call('/tmp/path')
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hydra-works
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Justin Coyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-04 00:00:00.000000000 Z
+date: 2016-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hydra-pcdm
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: hydra-derivatives
   requirement: !ruby/object:Gem::Requirement
@@ -191,20 +191,15 @@ files:
 - hydra-works.gemspec
 - lib/hydra/works.rb
 - lib/hydra/works/characterization.rb
+- lib/hydra/works/characterization/fits_datastream.rb
+- lib/hydra/works/characterization/fits_mapper.rb
 - lib/hydra/works/characterization/schema/audio_schema.rb
 - lib/hydra/works/characterization/schema/base_schema.rb
 - lib/hydra/works/characterization/schema/document_schema.rb
 - lib/hydra/works/characterization/schema/image_schema.rb
 - lib/hydra/works/characterization/schema/video_schema.rb
-- lib/hydra/works/models/characterization/already_there_strategy.rb
-- lib/hydra/works/models/characterization/fits_datastream.rb
 - lib/hydra/works/models/collection.rb
 - lib/hydra/works/models/concerns/collection_behavior.rb
-- lib/hydra/works/models/concerns/file_set/characterization/audio.rb
-- lib/hydra/works/models/concerns/file_set/characterization/base.rb
-- lib/hydra/works/models/concerns/file_set/characterization/document.rb
-- lib/hydra/works/models/concerns/file_set/characterization/image.rb
-- lib/hydra/works/models/concerns/file_set/characterization/video.rb
 - lib/hydra/works/models/concerns/file_set/contained_files.rb
 - lib/hydra/works/models/concerns/file_set/derivatives.rb
 - lib/hydra/works/models/concerns/file_set/mime_types.rb
@@ -220,6 +215,7 @@ files:
 - lib/hydra/works/services/characterization_service.rb
 - lib/hydra/works/services/persist_derivative.rb
 - lib/hydra/works/services/upload_file_to_file_set.rb
+- lib/hydra/works/services/virus_checker_service.rb
 - lib/hydra/works/version.rb
 - lib/hydra/works/vocab/works_terms.rb
 - solr/config/_rest_managed.json
@@ -259,6 +255,7 @@ files:
 - spec/fixtures/test5.mp3
 - spec/fixtures/updated-file.txt
 - spec/fixtures/world.png
+- spec/hydra/works/characterization_spec.rb
 - spec/hydra/works/models/characterization/fits_datastream_spec.rb
 - spec/hydra/works/models/collection_spec.rb
 - spec/hydra/works/models/concerns/file_set/contained_files_spec.rb
@@ -272,6 +269,7 @@ files:
 - spec/hydra/works/services/characterization_service_spec.rb
 - spec/hydra/works/services/persist_derivatives_spec.rb
 - spec/hydra/works/services/upload_file_spec.rb
+- spec/hydra/works/services/virus_checker_service_spec.rb
 - spec/hydra/works_spec.rb
 - spec/spec_helper.rb
 - spec/support/file_set_helper.rb
@@ -304,7 +302,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: Fundamental repository data model for hydra
@@ -330,6 +328,7 @@ test_files:
 - spec/fixtures/test5.mp3
 - spec/fixtures/updated-file.txt
 - spec/fixtures/world.png
+- spec/hydra/works/characterization_spec.rb
 - spec/hydra/works/models/characterization/fits_datastream_spec.rb
 - spec/hydra/works/models/collection_spec.rb
 - spec/hydra/works/models/concerns/file_set/contained_files_spec.rb
@@ -343,6 +342,7 @@ test_files:
 - spec/hydra/works/services/characterization_service_spec.rb
 - spec/hydra/works/services/persist_derivatives_spec.rb
 - spec/hydra/works/services/upload_file_spec.rb
+- spec/hydra/works/services/virus_checker_service_spec.rb
 - spec/hydra/works_spec.rb
 - spec/spec_helper.rb
 - spec/support/file_set_helper.rb

data/lib/hydra/works/models/characterization/already_there_strategy.rb

@@ -1,12 +0,0 @@
-module Hydra::Works::Characterization
-  class AlreadyThereStrategy < ActiveTriples::ExtensionStrategy
-    # override apply method to check if property already exists or reciever already has predicate defined.
-    # Do not add property if the rdf_resource already responds to the property name
-    # Do not add property if the rdf_resource already has a property with the same predicate.
-    def self.apply(resource, property)
-      return if resource.respond_to?(property.name)
-      return if resource.properties.any? { |p| p[1].predicate == property.predicate }
-      resource.property property.name, property.to_h
-    end
-  end
-end

data/lib/hydra/works/models/concerns/file_set/characterization/audio.rb

@@ -1,14 +0,0 @@
-module Hydra::Works::Characterization
-  module Audio
-    extend ActiveSupport::Concern
-
-    included do
-      # Apply the audio schema. This will add properties defined in the schema.
-      apply_schema AudioSchema, AlreadyThereStrategy
-
-      # Update the configuration to map the parsed terms to the correct property.
-      parser_mapping.merge!(audio_sample_rate: :sample_rate,
-                            audio_duration: :duration)
-    end
-  end
-end

data/lib/hydra/works/models/concerns/file_set/characterization/base.rb

@@ -1,23 +0,0 @@
-module Hydra::Works::Characterization
-  module Base
-    extend ActiveSupport::Concern
-
-    included do
-      # Apply the base schema. This will add properties defined in the schema.
-      apply_schema BaseSchema, AlreadyThereStrategy
-
-      # Parser config is :term => :property.
-      # Use this config to override the default behavior of value assignment which is:
-      # value is assigned to the property with the same name as the characterization term.
-      # use parser_config.merge! for subsequent modules.
-      class_attribute :parser_mapping
-      self.parser_mapping = { exif_tool_version: :exif_version,
-                              file_mime_type: :mime_type }
-
-      # Parser class is an OM terminology.
-      # It maps the characterization tool's output xml to terms and values.
-      class_attribute :parser_class
-      self.parser_class = FitsDatastream
-    end
-  end
-end

data/lib/hydra/works/models/concerns/file_set/characterization/document.rb

@@ -1,11 +0,0 @@
-module Hydra::Works::Characterization
-  module Document
-    extend ActiveSupport::Concern
-
-    included do
-      # Apply the document schema. This will add properties defined in the schema.
-      apply_schema DocumentSchema, AlreadyThereStrategy
-      parser_mapping.merge!(file_author: :creator, file_language: :language)
-    end
-  end
-end

data/lib/hydra/works/models/concerns/file_set/characterization/image.rb

@@ -1,10 +0,0 @@
-module Hydra::Works::Characterization
-  module Image
-    extend ActiveSupport::Concern
-
-    included do
-      # Apply the image schema. This will add properties defined in the schema.
-      apply_schema ImageSchema, AlreadyThereStrategy
-    end
-  end
-end

data/lib/hydra/works/models/concerns/file_set/characterization/video.rb

@@ -1,17 +0,0 @@
-module Hydra::Works::Characterization
-  module Video
-    extend ActiveSupport::Concern
-
-    included do
-      # Apply the module schema. This will add properties defined in the schema.
-      apply_schema VideoSchema, AlreadyThereStrategy
-
-      # Update the configuration to map the parsed terms to the correct property.
-      parser_mapping.merge!(video_sample_rate: :sample_rate,
-                            video_audio_sample_rate: :sample_rate,
-                            video_duration: :duration,
-                            video_width: :width,
-                            video_height: :height)
-    end
-  end
-end