jhove-service 1.4.1

data/bin/jhove-README-1st.txt

@@ -0,0 +1,2 @@
+http://jhove.openpreservation.org/getting-started/
+http://jhove.openpreservation.org/documentation/

data/bin/jhove.conf

@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<jhoveConfig version="1.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns="http://hul.harvard.edu/ois/xml/ns/jhove/jhoveConfig"
+ xsi:schemaLocation="http://hul.harvard.edu/ois/xml/ns/jhove/jhoveConfig
+                     http://cosimo.stanford.edu/standards/jhove/v1/jhoveConfig.xsd">
+  <jhoveHome></jhoveHome>
+ <defaultEncoding>utf-8</defaultEncoding>
+ <tempDirectory>/tmp</tempDirectory>
+ <bufferSize>131072</bufferSize>
+ <mixVersion>1.0</mixVersion>
+ <sigBytes>1024</sigBytes>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.AiffModule</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.WaveModule</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.PdfModule</class>
+  <param>p</param>
+ </module>
+ <module>
+  <class>com.mcgath.jhove.module.PngModule</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.Jpeg2000Module</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.JpegModule</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.GifModule</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.TiffModule</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.XmlModule</class>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml11.xsd;cache/xhtml11.xsd</param>
+  <param>schema=http://www.w3.org/2001/xml.xsd;cache/xml.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml11-model-1.xsd;cache/xhtml11-model-1.xsd</param>
+  <param>schema=https://www.w3.org/markUp/schema/xhtml11-model-1.xsd;cache/xhtml11-model-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml11-modules-1.xsd;cache/xhtml11-modules-1.xsd</param>
+  <param>schema=https://www.w3.org/markUp/schema/xhtml11-modules-1.xsd;cache/xhtml11-modules-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-attribs-1.xsd;cache/xhtml-attribs-1.xsd</param>
+  <param>schema=https://www.w3.org/markUp/schema/xhtml-attribs-1.xsd;cache/xhtml-attribs-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-base-1.xsd;cache/xhtml-base-1.xsd</param>
+  <param>schema=https://www.w3.org/markUp/schema/xhtml-blkphras-1.xsd;cache/xhtml-blkphras-1.xsd</param>
+  <param>schema=https://www.w3.org/markUp/schema/xhtml-blkpres-1.xsd;cache/xhtml-blkpres-1.xsd</param>
+  <param>schema=https://www.w3.org/markUp/schema/xhtml-blkstruct-1.xsd;cache/xhtml-blkstruct-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-bdo-1.xsd;cache/xhtml-bdo-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-csismap-1.xsd;cache/xhtml-csismap-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-datatypes-1.xsd;cache/xhtml-datatypes-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-edit-1.xsd;cache/xhtml-edit-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-events-1.xsd;cache/xhtml-events-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-form-1.xsd;cache/xhtml-form-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-framework-1.xsd;cache/xhtml-framework-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-hypertext-1.xsd;cache/xhtml-hypertext-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-image-1.xsd;cache/xhtml-image-1.xsd</param>
+  <param>schema=https://www.w3.org/markUp/schema/xhtml-inlphras-1.xsd;cache/xhtml-inlphras-1.xsd</param>
+  <param>schema=https://www.w3.org/markUp/schema/xhtml-inlpres-1.xsd;cache/xhtml-inlpres-1.xsd</param>
+  <param>schema=https://www.w3.org/markUp/schema/xhtml-inlstruct-1.xsd;cache/xhtml-inlstruct-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-inlstyle-1.xsd;cache/xhtml-inlstyle-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-link-1.xsd;cache/xhtml-link-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-list-1.xsd;cache/xhtml-list-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-meta-1.xsd;cache/xhtml-meta-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-object-1.xsd;cache/xhtml-object-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-param-1.xsd;cache/xhtml-param-1.xsd</param>
+  <param>schema=https://www.w3.org/markUp/schema/xhtml-param-1.xsd;cache/xhtml-param-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-pres-1.xsd;cache/xhtml-pres-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-ruby-1.xsd;cache/xhtml-ruby-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-script-1.xsd;cache/xhtml-script-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-ssismap-1.xsd;cache/xhtml-ssismap-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-struct-1.xsd;cache/xhtml-struct-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-style-1.xsd;cache/xhtml-style-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-table-1.xsd;cache/xhtml-table-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-target-1.xsd;cache/xhtml-target-1.xsd</param>
+  <param>schema=http://www.w3.org/markUp/schema/xhtml-text-1.xsd;cache/xhtml-text-1.xsd</param> </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.HtmlModule</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.WarcModule</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.GzipModule</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.AsciiModule</class>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.Utf8Module</class>
+ </module>
+ <outputHandler>
+  <class>edu.harvard.hul.ois.jhove.handler.XmlHandler</class>
+ </outputHandler>
+</jhoveConfig>

data/bin/jhoveToolkit.sh

@@ -0,0 +1,87 @@
+#!/bin/sh
+
+########################################################################
+# JHOVE - JSTOR/Harvard Object Validation Environment
+# Copyright 2003-2005 by JSTOR and the President and Fellows of Harvard College
+# JHOVE is made available under the GNU General Public License (see the
+# file LICENSE for details)
+#
+# Usage: jhove [-c config] [-m module] [-h handler] [-e encoding] [-H handler]
+#              [-o output] [-x saxclass] [-t tempdir] [-b bufsize]
+#              [-l loglevel] [[-krs] dir-file-or-uri [...]]
+#
+# where -c config   Configuration file pathname
+#       -m module   Module name
+#       -h handler  Output handler name (defaults to TEXT)
+#       -e encoding Character encoding of output handler (defaults to UTF-8)
+#       -H handler  About handler name
+#       -o output   Output file pathname (defaults to standard output)
+#       -x saxclass SAX parser class (defaults to J2SE 1.4 default)
+#       -t tempdir  Temporary directory in which to create temporary files
+#       -b bufsize  Buffer size for buffered I/O (defaults to J2SE 1.4 default)
+#       -k          Calculate CRC32, MD5, and SHA-1 checksums
+#       -r          Display raw data flags, not textual equivalents
+#       -s          Format identification based on internal signatures only
+#       dir-file-or-uri Directory, file pathname or URI of formatted content
+#
+# CHANGE for JHOVE 1.8:
+# You no longer have to figure out where JAVA_HOME is; that's the
+# operating system's job. If the OS tells you it can't find Java,
+# adjust your shell's path or revert to the old way (commented out).
+# Configuration constants:
+
+# Infer JHOVE_HOME from script location
+SCRIPT="${0}"
+
+echo ${SCRIPT}
+
+# Resolve absolute and relative symlinks
+while [ -h "${SCRIPT}" ]; do
+    LS=$( ls -ld "${SCRIPT}" )
+    LINK=$( expr "${LS}" : '.*-> \(.*\)$' )
+    if expr "${LINK}" : '/.*' > /dev/null; then
+        SCRIPT="${LINK}"
+    else
+        SCRIPT="$( dirname "${SCRIPT}" )/${LINK}"
+    fi
+done
+
+# Store absolute location
+CWD="$( pwd )"
+JHOVE_HOME="$( cd "$(dirname "${SCRIPT}" )" && pwd )"
+cd "${CWD}" || exit
+export JHOVE_HOME
+
+JHOVE_VERSION=1.24.0-RC1
+JAVA_HOME=/etc/alternatives/jre
+JAVA=/usr/bin/java
+
+CP=${JHOVE_HOME}/jhove-apps-${JHOVE_VERSION}.jar:${JHOVE_HOME}/jhove-ext-modules-${JHOVE_VERSION}.jar
+CP=${CP}:${JHOVE_HOME}/aiff-hul-1.6.1-RC1.jar
+CP=${CP}:${JHOVE_HOME}/ascii-hul-1.4.1.jar
+CP=${CP}:${JHOVE_HOME}/gif-hul-1.4.2-RC1.jar
+CP=${CP}:${JHOVE_HOME}/html-hul-1.4.1.jar
+CP=${CP}:${JHOVE_HOME}/jpeg-hul-1.5.2-RC1.jar
+CP=${CP}:${JHOVE_HOME}/jpeg2000-hul-1.4.2-RC1.jar
+CP=${CP}:${JHOVE_HOME}/pdf-hul-1.12.2-RC1.jar
+CP=${CP}:${JHOVE_HOME}/tiff-hul-1.9.2-RC1.jar
+CP=${CP}:${JHOVE_HOME}/utf8-hul-1.7.1.jar
+CP=${CP}:${JHOVE_HOME}/wave-hul-1.8.1-RC1.jar
+CP=${CP}:${JHOVE_HOME}/xml-hul-1.5.1.jar
+
+# Retrieve a copy of all command line arguments to pass to the application.
+# Since looping over the positional parameters is such a common thing to do in scripts,
+#   for arg
+# defaults to
+#   for arg in "$@".
+# The double-quoted "$@" is special magic that causes each parameter to be used as a single word
+
+ARGS="-c ${JHOVE_HOME}/jhove.conf"
+for ARG do
+    ARGS="$ARGS $ARG"
+done
+
+echo $JHOVE_HOME
+
+# Set the CLASSPATH and invoke the Java loader.
+${JAVA} -Xms128M -Xmx6000M -classpath $CP Jhove $ARGS

data/lib/jhove_service.rb

@@ -0,0 +1,127 @@
+require 'nokogiri'
+require 'pathname'
+require 'jhove_technical_metadata'
+require 'stringio'
+require 'uri'
+require 'shellwords'
+require 'open3'
+
+class JhoveService
+
+  # @return [Pathname] The directory in which program files are located
+  attr_accessor :bin_pathname
+
+  # @return [Pathname] The directory in which output should be generated
+  attr_accessor :target_pathname
+
+  # @return [String] The druid of the object, which gets inserted in the root element of the output
+  attr_accessor :digital_object_id
+
+  # @param [String] target_dir The  directory into which output should be generated
+  def initialize(target_dir=nil)
+    @target_pathname = Pathname.new(target_dir) unless target_dir.nil?
+    @bin_pathname = Pathname.new(File.expand_path(File.dirname(__FILE__) + '/../bin'))
+  end
+
+  # @return [String] The output file from the JHOVE run
+  def jhove_output
+    @target_pathname.join('jhove_output.xml')
+  end
+
+  # @return [String] The technicalMetadata.xml output file path
+  def tech_md_output
+    @target_pathname.join('technicalMetadata.xml')
+  end
+
+  # @param content_dir [Pathname,String] the directory path containing the files to be analyzed by JHOVE
+  # @param fileset_file [Pathname,String] the pathname of the file listing which files should be processed.  If nil, process all files.
+  # @return [String] Run JHOVE to characterize all content files, returning the output file path
+  def run_jhove(content_dir, fileset_file=nil)
+    raise "Content #{content_dir} not found" unless File.directory? content_dir
+    if fileset_file.nil? # a simple directory gets called directly
+      exec_command(get_jhove_command(content_dir))
+      jhove_output_xml_ng = File.open(jhove_output) { |f| Nokogiri::XML(f) }
+    else # a filelist gets run one by one, jhove cannot do this out of the box, so we need to run jhove file by file and then assemble the results ourselves into a single XML
+      raise "File list #{fileset_file} not found" unless File.exists? fileset_file
+      files = File.new(fileset_file).readlines
+      raise "File list #{fileset_file} empty" if files.size == 0
+      combined_xml_output = ""
+      jhove_output_xml_ng = Nokogiri::XML('')
+      files.each_with_index do |filename,i| # generate jhove output for each file in a separate xml file
+        full_path_to_file = File.join(content_dir,filename.strip)
+        output_file = @target_pathname.join("jhove_output_#{i}.xml")
+        exec_command(get_jhove_command(full_path_to_file,output_file))
+        jhove_output_xml_ng = File.open(output_file) { |f| Nokogiri::XML(f) }
+        combined_xml_output += jhove_output_xml_ng.css("//repInfo").to_xml # build up an XML string with all output
+        output_file.delete
+      end
+      jhove_output_xml_ng.root.children.each {|n| n.remove} # use all of the files we built up above, strip all the children to get the root jhove node
+      jhove_output_xml_ng.root << combined_xml_output # now add the combined xml for all files
+    end
+    remove_path_from_file_nodes(jhove_output_xml_ng,content_dir)
+    File.write(jhove_output, jhove_output_xml_ng.to_xml)
+    jhove_output.to_s
+  end
+
+  # @param command [String] the command to execute on the command line
+  # @raises [RuntimeError] if there is a problem running the command
+  def exec_command(command)
+    stdout, stderr, status = Open3.capture3(command, chdir: @bin_pathname)
+    raise "Error when running JHOVE #{command}:\n#{stderr}" unless status.success?
+  end
+
+  # @param input_path  [Pathname,String] the directory path or filename containing the folder or file to be analyzed by JHOVE
+  # @param output_file [Pathname,String] the output file to write the XML to, defaults to filename specified in jhove_output
+  # @return [String] The jhove-toolkit command to be exectuted in a system call
+  def get_jhove_command(input_path,output_file = jhove_output)
+    filename = Shellwords.escape(input_path) # escape any special characters in the path
+    args = "-h xml -o \"#{output_file}\" \\\"#{filename}"
+    jhove_script = './jhoveToolkit.sh'
+    jhove_cmd = "#{jhove_script} #{args}"
+    jhove_cmd
+  end
+
+  # @param jhove_output_xml_ng [ng_xml_obj] the nokogiri xml output from jhove
+  # @param path [String] the shared path that will be removed from each file name to ensure the file nodes are relative
+  def remove_path_from_file_nodes(jhove_output_xml_ng,path)
+    jhove_output_xml_ng.xpath('//jhove:repInfo', 'jhove' => 'http://schema.openpreservation.org/ois/xml/ns/jhove').each do |filename_node|
+      filename_node.attributes['uri'].value = URI.decode(filename_node.attributes['uri'].value.gsub("#{path}",'').sub(/^\//,'')) # decode and remove path and any leading /
+    end
+  end
+
+  # @param [Pathname,String] jhove_pathname The full path of the file containing JHOVE output to be transformed to technical metadata
+  # @return [String] Convert jhove output it to technicalMetadata, returning the output file path
+  def create_technical_metadata(jhove_pathname=jhove_output)
+    jhove_pathname = Pathname.new(jhove_pathname)
+    jhovetm = JhoveTechnicalMetadata.new()
+    jhovetm.digital_object_id=self.digital_object_id
+    jhovetm.output_file=tech_md_output
+    # Create a SAX parser
+    parser = Nokogiri::XML::SAX::Parser.new(jhovetm)
+    # Feed the parser some XML
+    parser.parse(jhove_pathname.open('rb'))
+    tech_md_output.to_s
+  end
+
+  # @param [String] old_tm the old techMD xml to be transformed to new technical metadata format
+  # @return [String] Convert old techMD date to new technicalMetadata format
+  def upgrade_technical_metadata(old_tm)
+    new_tm = StringIO.new()
+    upgrade_sax_handler = JhoveTechnicalMetadata.new()
+    upgrade_sax_handler.digital_object_id=self.digital_object_id
+    upgrade_sax_handler.ios = new_tm
+    # Create a SAX parser
+    parser = Nokogiri::XML::SAX::Parser.new(upgrade_sax_handler)
+    # Feed the parser some XML
+    parser.parse(old_tm)
+    new_tm.string
+  end
+
+
+  # @return [void] Cleanup the temporary workspace used to hold the metadata outputs
+  def cleanup()
+    jhove_output.delete if jhove_output.exist?
+    tech_md_output.delete if tech_md_output.exist?
+  end
+
+end

data/lib/jhove_technical_metadata.rb

@@ -0,0 +1,284 @@
+require 'rubygems'
+require 'nokogiri'
+require 'time'
+require 'pathname'
+
+# A SAX handler for filtering JHOVE output to create a technicalMetadata datastream
+# The previous mechanism (uising XSLT tranformation) was causing out of memory errors,
+# due to XSLT's behavior of loading both the input and output objects into memory.
+class JhoveTechnicalMetadata < Nokogiri::XML::SAX::Document
+
+  # @return [IO] the output stream for the result
+  attr_accessor :ios
+
+  # @return [String] The druid of the object, which gets inserted in the root element of the output
+  attr_accessor :digital_object_id
+
+  def initialize()
+    @indent = 0
+    @ios = STDOUT #File.open(STDOUT, 'w')
+  end
+
+  # @param [Pathname] pathname the location of the technicalMetadata.xml file to be created
+  # @return [void] Opens the output stream pointing to the specified file
+  def output_file=(pathname)
+    @ios = pathname.open('w')
+  end
+
+  # @param [String] string The character string to be appended to the output
+  # @return [void] Append the specified string to the output stream
+  def output(string)
+    @ios.puts "  "*@indent + string
+  end
+
+  # @param [String] tag the name of the XML element from the parsed input
+  # @param [Hash] attrs the XML attributes of the element
+  # @return [void] this method is called by the sax parser at the beginning of an element
+  def start_element(tag, attrs = [])
+    case tag
+      when 'jhove'
+        # <jhove> is the root element of the input
+        root_open(attrs)
+      when 'repInfo'
+        # A <repInfo> element contains the data for each file
+        file_wrapper_open(attrs)
+      when 'properties'
+        # A <properties> element contains the variable data for the file
+        properties_open
+      else
+        if tag[0..2] == 'mix'
+          # JHOVE output for image files contains tech md in MIX format that we copy verbatum to output
+          mix_open(tag)
+        elsif @in_jhove
+          # we've encountered one of the JHOVE elements that we want to automatically copy
+          jhove_open(tag, attrs)
+        elsif @in_properties
+          # we're looking for the LineEndings property in the JHOVE output
+          linebreak_open(tag)
+        end
+    end
+  end
+
+  # @param [String] tag the value of a text node found in the parsed XML
+  # @return [void] this method is called by the sax parser when a text node is encountered
+  def characters(string)
+    @text = string
+  end
+
+  # @param [String] tag the name of the XML element from the parsed input
+  # @return [void] this method is called by the sax parser at the end of an element
+  def end_element(tag)
+    case tag
+      when 'jhove'
+        root_close
+      when 'repInfo'
+        file_wrapper_close
+      when 'properties'
+        properties_close
+      else
+        if tag[0..2] == 'mix'
+          mix_close(tag)
+        elsif @in_jhove
+          jhove_close(tag)
+        elsif @in_properties
+          linebreak_close(tag)
+        end
+    end
+  end
+
+  # @param [Hash] attrs the attributes of the <jhove> element in the XML input
+  # @return [void] create the <technicalMetadata> root element of the XML output and include namespace declararions
+  def root_open(attrs)
+    if @digital_object_id
+      output "<technicalMetadata objectId='#{@digital_object_id}' datetime='#{Time.now.utc.iso8601}'"
+    else
+      output "<technicalMetadata datetime='#{Time.now.utc.iso8601}'"
+    end
+    @indent += 2
+    output "xmlns:jhove='http://hul.harvard.edu/ois/xml/ns/jhove'"
+    output "xmlns:mix='http://www.loc.gov/mix/v10'"
+    output "xmlns:textmd='info:lc/xmlns/textMD-v3' >"
+    @indent -= 1
+  end
+
+  # @return [void] add the closing element of the output document
+  def root_close
+    @indent -= 1
+    output "</technicalMetadata>"
+    @ios.close
+  end
+
+  # @param [Hash] attrs the attributes of the <jhove> element in the XML input
+  # @return [void] Append a <file> element to the output, setting the id attribute to the file path
+  def file_wrapper_open(attrs)
+    filepath=nil
+    attrs.each { |attr| filepath=attr[1] if attr[0]=='uri'}
+    output "<file id='#{filepath}'>"
+    @indent += 1
+    @in_jhove = true
+  end
+
+  # @return [void] Append a </file> tag to close the file data,
+  # but first inset a textMD stanza if the file has a text format
+  def file_wrapper_close
+    case @format
+      when 'ASCII', 'HTML','TEXT','UTF-8'
+        output_textmd(@linebreak)
+    end
+    @indent -= 1
+    output "  </jhove:properties>" if @in_properties
+
+    output "</file>"
+    @in_jhove = false
+    @in_properties=false
+  end
+
+  # @param [String] tag the name of the XML element from the parsed input
+  # @param [Hash] attrs the attributes of the <jhove> element in the XML input
+  # @return [void] Copy this jhove element tag and its attributes verbatum
+  def jhove_open(tag, attrs)
+     if @jhove_tag # saved previously
+       # we encountered a new element so output what was previously cached
+       output "<jhove:#{@jhove_tag}#{@jhove_attrs}>"
+       @indent += 1
+     end
+     # cache the element name and its attributes
+     @jhove_tag = tag
+     @jhove_attrs = ""
+     attrs.each do |attr|
+       @jhove_attrs += " #{attr[0]}='#{attr[1]}'"
+     end
+     @text = nil
+     @linebreak='LF'
+   end
+
+  # @param [String] tag the name of the XML element from the parsed input
+   # @return [void] Output a closing tag, preceded by cached data, if such exists
+   def jhove_close(tag)
+     if @text && tag == @jhove_tag
+       output "<jhove:#{@jhove_tag}#{@jhove_attrs}>#{@text}</jhove:#{tag}>"
+     elsif tag == @jhove_tag
+       output "<jhove:#{@jhove_tag}#{@jhove_attrs}/>"
+     else
+       @indent -=1
+       output "</jhove:#{tag}>"
+     end
+     @format = @text if tag == 'format'
+     @text = nil
+     @jhove_tag = nil
+     @jhove_attrs=""
+   end
+
+   # @return [void] Output a <properties> element if one was encountered in the input,
+   #   then ignore most input data from within the properties element, except mix and LineBreaks
+  def properties_open
+    output "<jhove:properties>"
+    @indent += 1
+    @in_jhove = false
+    @in_properties=true
+  end
+
+  # @return [void] Appending of a closing tag is handled elsewhere
+  def properties_close
+    @indent -= 1
+  end
+
+  # @param [String] tag the name of the XML element from the parsed input
+  # @return [void] Copy any Mix data verbatum,
+  def mix_open(tag)
+    if @mix_tag
+      # we encountered a new element so output what was previously cached
+      output "<#{@mix_tag}>"
+      @indent += 1
+    end
+     # cache the element name
+    @mix_tag = tag
+    @text = nil
+  end
+
+  # @param [String] tag the name of the XML element from the parsed input
+  # @return [void] Output a closing tag, preceded by cached data, if such exists
+  def mix_close(tag)
+    if @text && tag == @mix_tag
+      output "<#{tag}>#{@text}</#{tag}>"
+    elsif tag == @mix_tag
+        output "<#{tag}/>"
+    else
+      @indent -=1
+      output "</#{tag}>"
+    end
+    @text = nil
+    @mix_tag = nil
+  end
+
+  # @param [String] tag the name of the XML element from the parsed input
+  # @return [void] Keep clearing the text cache any time a new element is encountered
+  def linebreak_open(tag)
+    @text = nil if @text
+  end
+
+  # @param [String] tag the name of the XML element from the parsed input
+  # @return [void] Look for the LineEndings name/value pair, which is spread across multiple elements
+  def linebreak_close(tag)
+    case tag
+      when 'name'
+        @in_line_endings = false
+        @in_line_endings = true if @text == 'LineEndings'
+      when 'value'
+        @linebreak = @text if @in_line_endings
+        @in_line_endings = false
+    end
+  end
+
+  # @param [Object] linebreak the CRLF or LF value found in the JHOVE output ()default is LF)
+  # @return [void] Output a textMD section within the properties element
+  def output_textmd(linebreak)
+    indent = @indent
+    @indent = 0
+    if @in_properties
+      # properties element tags provided by other code
+      output <<-EOF
+      <textmd:textMD>
+        <textmd:character_info>
+          <textmd:byte_order>big</textmd:byte_order>
+          <textmd:byte_size>8</textmd:byte_size>
+          <textmd:character_size>1</textmd:character_size>
+          <textmd:linebreak>#{linebreak}</textmd:linebreak>
+        </textmd:character_info>
+      </textmd:textMD>
+      EOF
+    else
+      # there were no properties elements in the input, so we must supply them ourselves
+      output <<-EOF
+      <jhove:properties>
+        <textmd:textMD>
+          <textmd:character_info>
+            <textmd:byte_order>big</textmd:byte_order>
+            <textmd:byte_size>8</textmd:byte_size>
+            <textmd:character_size>1</textmd:character_size>
+            <textmd:linebreak>#{linebreak}</textmd:linebreak>
+          </textmd:character_info>
+        </textmd:textMD>
+      </jhove:properties>
+      EOF
+    end
+    @indent = indent
+  end
+
+end
+
+
+# Below is the equivalent of a java main method.
+# For this to work OK, the module/class being invoked
+# must have already have been loaded by the Ruby interpreter.
+
+if __FILE__ == $0
+  # Create a handler
+  jhovetm = JhoveTechnicalMetadata.new()
+  jhovetm.digital_object_id=ARGV[0]
+  jhovetm.output_file=Pahtname.new(ARGV[2])
+  # Create a SAX parser
+  parser = Nokogiri::XML::SAX::Parser.new(jhovetm)
+  # Feed the parser some XML
+  parser.parse(File.open(ARGV[1], 'rb'))
+end