jhove-service 1.0.3

data/LICENSE.rdoc

@@ -0,0 +1,23 @@
+Copyright (c) 2013 by The Board of Trustees of the Leland Stanford Junior
+University.  All rights reserved.
+
+Redistribution and use of this distribution in source and binary forms,
+with or without modification, are permitted provided that:
+* The above copyright notice and this permission notice appear in all copies and supporting documentation;
+* The name, identifiers, and trademarks of The Board of Trustees
+  of the Leland Stanford Junior University are not used in advertising or publicity
+  without the express prior written permission of The Board of Trustees
+  of the Leland Stanford Junior University;
+* Recipients acknowledge that this distribution is made available as a research courtesy,
+  "as is", potentially with defects, without any obligation on the part
+  of The Board of Trustees of the Leland Stanford Junior University to provide support,
+  services, or repair;
+
+THE BOARD OF TRUSTEES OF THE LELAND STANFORD JUNIOR UNIVERSITY DISCLAIMS ALL WARRANTIES,
+EXPRESS OR IMPLIED, WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT LIMITATION
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE,
+AND IN NO EVENT SHALL THE BOARD OF TRUSTEES OF THE LELAND STANFORD JUNIOR UNIVERSITY
+BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, TORT
+(INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF OR IN CONNECTION
+WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/README.rdoc

@@ -0,0 +1,28 @@
+= jhove-service
+
+Require the following:
+  require 'jhove_service'
+
+
+This will give you:
+  JhoveService
+
+== Build and release procedure
+Modify the version number in jhove-service.gemspec, then push your commits to AFS.  DO NOT TAG!
+Run: 'rake dlss_release' to tag, build, and publish the gem
+See the Rakefile and the LyberCore::DlssRelease task in lyberteam-devel/lib/dlss/rake/dlss_release.rb
+for more details
+
+== Releases
+- <b>0.1.0</b> First release
+- <b>0.1.1</b> Rename temp to target (location in which to create output)
+- <b>0.2.0</b> Change method of transforming JHOVE output to technicalMetadata
+- <b>0.2.1</b> Enable processing of a subset of files in a directory
+- <b>0.2.2</b> Enable upgrading of old technical metadata to the new format
+- <b>1.0.0</b> Update JhoveToolkit.jar to v1.0.0. Fix output for filetypes w/o jhove module (bytestreams)
+- <b>1.0.1</b> Updated to use new sul-gems server and new lyberteam-gems-devel utility
+- <b>1.0.2</b> Fixed negative indentation problem for empty elements( e.g. <elem/>)
+- <b>1.0.3</b> Upgraded bin/jhoveApp.jar to copy from Jhove 1.9 release
+== Copyright
+
+Copyright (c) 2013 Stanford University Library. See LICENSE for details.

data/bin/extension-mimetype.conf

@@ -0,0 +1,209 @@
+3dmf=x-world/x-3dmf
+ai=application/vnd.adobe-illustrator
+aif=audio/x-aiff
+aifc=audio/x-aiff
+aiff=audio/x-aiff
+als=image/x-vivid
+art=image/x-first-publisher-art
+asc=image/x-hp-graphic-obj
+asf=video/x-ms-asf
+asp=text/html
+asx=video/x-ms-asx
+au=audio/x-au
+avi=video/x-msvideo
+bcpio=application/dca-rft
+bin=application/macbinary
+bm=image/x-xbitmap
+bmp=image/bmp
+c4=image/x-ccitt4
+cal=image/x-cals
+cals=image/x-cals
+ccrf=image/x-calcomp-ccrf
+cdda=audio/x-aiff
+cdr=image/vnd.corel-draw
+cel=image/x-lumena-cel
+cfm=text/html
+cgi=text/html
+class=application/octet-stream
+clp=application/x-pcpaint
+cm=image/x-puzzle
+cpio=application/x-DisplayWrite-txt
+crf=image/x-calcomp-ccrf
+css=text/css
+ct=image/x-scitex-ct
+dcr=application/x-director
+dcx=image/x-pcx
+dir=application/x-director
+doc=application/vnd.ms-word
+dvi=application/x-dvi
+dxf=application/x-autoCAD-dxf
+dxr=application/x-director
+eml=text/plain
+epi=image/x-eps-interchange
+eps=image/eps
+epsf=image/eps
+epsi=image/x-eps-interchange
+etx=text/x-setextetx
+evy=application/x-envoy
+exe=application/octet-stream
+fh7=application/vnd.mm-freehand
+fif=image/x-fractal
+gif=image/gif
+gis=application/x-erdas-lan
+gm=image/x-autologic-gm
+gm2=image/x-autologic-gm
+gm4=image/x-autologic-gm
+goe=image/x-goes
+goes=image/x-goes
+grb=image/x-hp-graphic-obj
+gtar=application/x-gtar
+hdf=application/vnd.samna
+hpg=application/vnd.hp-HPGL
+hpgl=application/vnd.hp-HPGL
+hqx=application/mac-binhex40
+hrf=image/x-hitachi-raster
+htm=text/html
+html=text/html
+ico=image/x-sun-icon
+icon=image/x-sun-icon
+ics=application/ProWrite
+idc=image/x-core-idc
+ief=image/ief
+iff=image/x-iff-ilbm
+ilbm=image/x-iff-ilbm
+im=image/x-sun-raster
+im1=image/x-sun-raster
+im24=image/x-sun-raster
+im32=image/x-sun-raster
+im8=image/x-sun-raster
+img=image/x-vivid
+ind=application/vnd.adobe-indesign
+indd=application/vnd.adobe-indesign
+jpe=image/jpeg
+jpeg=image/jpeg
+jpg=image/jpeg
+jp2=image/jp2
+js=application/x-javascript
+kar=audio/midi
+lan=application/x-erdas-lan
+latex=application/x-latex
+lbm=image/x-iff-ilbm
+mac=image/x-iff-ilbm
+mcw=application/vnd.ms-word
+mdb=application/x-msaccess
+mht=text/html
+mid=audio/midi
+midi=audio/midi
+mif=application/vnd.framemaker-mif
+mov=video/quicktime
+movie=video/x-sgi-movie
+mp2=audio/x-mpeg
+MP2=audio/x-mpeg
+mp3=audio/x-mpeg
+mpa=audio/x-mpeg,video/x-mpeg
+mpe=video/mpeg
+mpeg=video/mpeg
+mpg=video/mpeg
+mpga=audio/x-mpeg
+ms-powerpoint=application/vnd.ms-powerpoint
+msword=application/vnd.ms-word
+mtv=image/x-mtv-ray
+navb=image/x-navb
+octet-stream=application/octet-stream
+oda=application/x-pfsWrite
+pat=image/x-us-patent
+pbm=image/x-portable-bitmap
+pcd=image/x-photo-cd
+pcl=application/vnd.hp-PCL
+pcx=image/x-pcx
+pdf=application/pdf
+pds=application/vnd.NASA-PDS
+pgm=image/x-portable-graymap
+photo=text/plain
+php=text/plain
+pic=image/x-macintosh-pict
+pict=image/x-macintosh-pict
+pjpeg=image/jpeg
+pl=text/plain
+pm=image/x-ibm-picture-mkr
+png=image/png
+pnm=image/x-portable-anymap
+ppm=image/x-portable-pixmap
+pps=application/vnd.ms-powerpoint
+ppt=application/vnd.ms-powerpoint
+ppz=application/vnd.ms-powerpoint
+prn=image/x-calcomp-ccrf
+ps=application/postscript
+psd=application/vnd.adobe-photoshop
+puzzle=image/x-puzzle
+pzl=image/x-puzzle
+qdv=image/x-qdv
+qpr=application/quattroPro
+qt=video/quicktime
+qxd=application/vnd.quark
+ra=audio/vnd.realaudio
+ram=audio/x-pn-realaudio
+ras=image/x-sun-raster
+rast=image/x-qdv
+raw=application/vnd.adobe-photoshop
+rg=image/x-raster-graphics
+rgb=image/x-rgb
+rix=image/x-rix
+rlc=image/x-rlc
+rle=image/x-utah-raster
+rm=audio/x-realmedia,video/vnd.realvideo
+rnc=application/vnd.relax-ng.rnc
+rtf=text/richtext
+rtl=application/vnd.hp-RTL
+scd=image/x-scodl
+scx=image/x-rix
+sea=application/sit
+sgi=image/x-sgi-image
+sgm=text/sgml
+sgml=text/sgml
+shtml=text/html
+sit=application/sit
+smil=application/smil  
+snd=audio/basic
+spl=application/futuresplash
+spr=application/x-sprite
+sprite=application/x-sprite
+sst=image/x-avhrr
+svp=video/x-pn-realvideo
+swf=application/x-shockwave-flash
+tar=application/x-tar
+tbk=application/toolbook
+tex=application/x-tex
+texi=application/x-FirstChoice
+texinfo=application/x-FirstChoice
+tga=image/x-targa
+tif=image/tiff
+tiff=image/tiff
+tsp=application/x-SmartDraw
+tsv=text/tab-separated-values
+txt=text/plain
+ustar=application/x-wordstar
+vi=image/x-jovian-vi
+vif=image/x-verity-image
+vit=image/x-vitec
+vrml=x-world/x-vrml
+wav=audio/x-wave
+wk1=application/vnd.lotus1-2-3
+wk3=application/vnd.lotus1-2-3
+wk4=application/vnd.lotus1-2-3
+wks=application/vnd.lotus1-2-3
+wma=audio/x-ms-wma
+wmv=video/x-ms-wmv
+wpd=application/wordperfect
+wpg=application/x-wordperfect-graphic
+wrl=x-world/x-vrml
+xbm=image/x-xbitmap
+xls=application/vnd.ms-excel
+xml=text/xml
+xsd=text/xml
+xsl=text/xml
+xpm=image/x-xpixmap
+x-png=image/png
+x-shockwave-flash=application/x-shockwave-flash
+xwd=image/x-xwindowdump
+zip=application/zip

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

@@ -0,0 +1,225 @@
+JHOVE - JSTOR/Harvard Object Validation Environment
+Copyright 2003-2008 by JSTOR and the President and Fellows of Harvard College
+JHOVE is made available under the GNU Lesser General Public License (LGPL;
+see the file LICENSE for details)
+
+Rev. 1.2, 2009-02-10
+
+JHOVE (the JSTOR/Harvard Object Validation Environment, pronounced "jhove")
+is an extensible software framework for performing format identification,
+validation, and characterization of digital objects.
+
+o Format identification is the process of determining the format to which a
+  digital object conforms: "I have a digital object; what format is it?"
+o Format validation is the process of determining the level of compliance of a
+  digital object to the specification for its purported format: "I have an
+  object purportedly of format F; is it?"
+o Format characterization is the process of determing the format-specific
+  significant properties of an object of a given format: "I have an object of
+  format F; what are its salient properties?"
+
+These actions are frequently necessary during routine operation of digital
+repositories and for digital preservation activities.
+
+The output from JHOVE is controlled by output handlers. JHOVE uses an
+extensible plug-in architecture; it can be configured at the time of its
+invocation to include whatever specific format modules and output handlers
+that are desired. The initial release of JHOVE includes modules for
+arbitrary byte streams, ASCII and UTF-8 encoded text, AIFF and WAVE audio,
+GIF, JPEG, JPEG 2000, TIFF, and PDF; and text and XML output handlers.
+
+The JHOVE project is a collaboration of JSTOR and the Harvard University
+Library.  Development of JHOVE was funded in part by the Andrew W. Mellon
+Foundation.  JHOVE is made available under the GNU Lesser General Public
+License (LGPL; see the file LICENSE for details).
+
+REQUIREMENTS
+
+1. Java J2SE 1.4
+(JHOVE was originally implemented using the Sun J2SE SDK 1.4.1 and has
+been tested to work with 1.4.2 <http://java.sun.com/j2se/1.4.2/>)
+
+2. If you would like to compile the JHOVE source code, then
+Apache Ant, a Java-based build tool <http://ant.apache.org/> is necessary.
+Note that the JAVA_HOME environment variable must be set appropriately for
+Ant to work properly.
+(JHOVE was implemented and tested using Ant 1.5.1.)
+
+DISTRIBUTION
+
+The JHOVE distribution package includes:
+
+    jhove/                                 # JHOVE home directory
+          COPYING                          # GNU Lesser General Public License
+          LICENSE                          # JHOVE license information
+          README
+          RELEASENOTES                     # JHOVE release notes
+          bin/
+                    jhove.jar              # JHOVE API package
+                    jhove-handler.jar      # Standard output handler package
+                    jhove-module.jar       # Standard module package
+                    JhoveApp.jar           # JHOVE command line application
+                    JhoveView.jar          # JHOVE with Swing GUI front-end
+          build.xml                        # Ant configuration file
+          classes/
+                    build.xml              # Ant configuration file
+                    edu/ ...               # JHOVE API packages
+                    ADump.*                # AIFF dump utility class
+                    GDump.*                # GIF dump utility class
+                    Jhove.*                # JHOVE main class
+                    JDump.*                # JPEG dump utility class
+                    J2Dump.*               # JPEG 2000 dump utility class
+                    PDump.*                # PDF dump utility class
+                    TDump.*                # TIFF dump utility class
+                    UserHome.*             # user.home property utility class
+                    WDump.*                # WAVE dump utility class
+          conf/
+                   jhove.conf              # JHOVE configuration file
+                   jhove.xsd               # JHOVE output schema
+                   jhoveConfig.xsd         # JHOVE configuration file schema
+          doc/
+                   *.html                  # API documentation
+                   ...
+          examples/                        # Sample files
+                   ascii/ ...
+                   gif/   ...
+                   jpeg/  ...
+                   jpeg2000/ ...
+                   pdf/   ...
+                   tiff/  ...
+                   utf-8/ ...
+          adump*                           # AIFF dump Bourne shell driver
+          adump.bat*                       # AIFF dump DOS shell driver script
+          gdump*                           # GIF dump Bourne shell driver
+          gdump.bat*                       # GIF dump DOS shell driver script
+          jdump*                           # JPEG dump Bourne shell driver
+          jdump.bat*                       # JPEG dump DOS shell driver script
+          j2dump*                          # JPEG 2000 dump Bourne shell driver
+          j2dump.bat*                      # JPEG 2000 dump DOS shell driver
+          jhove.tmpl*                      # Template for JHOVE Bourne shell driver script
+          jhove_bat.tmpl*                  # Template for JHOVE DOS shell driver script
+          pdump*                           # PDF dump Bourne shell driver
+          pdump.bat*                       # PDF dump DOS shell driver script
+          tdump*                           # TIFF dump Bourne shell driver
+          tdump.bat*                       # TIFF dump DOS shell driver script
+          userhome*                        # user.home Bourne shell driver
+          userhome.bat*                    # user.home DOS shell driver script
+          wdump*                           # WAVE dump Bourne shell driver
+          wdump.bat*                       # WAVE dump DOS shell driver script
+
+INSTALLATION
+
+Edit the configuration file, jhove/conf/jhove.conf, and set the absolute
+pathname of the JHOVE home directory and the temporary directory (in which
+temporary files are created):
+
+    <jhoveHome>jhove-home-directory</jhoveHome>
+    <tempDirectory>temporary-directory</tempDirectory>
+
+The JHOVE home directory is the top-most directory in the distribution TAR
+or ZIP file.  On Unix systems, "/var/tmp" is an appropriate temporary
+directory; on Windows, "C:\Temp".  For example, if the distribution TAR
+file is disaggregated on a Unix system in the directory "/users/stephen/
+projects", then the configuration file should read:
+
+    <jhoveHome>/users/stephen/projects/jhove</jhoveHome>
+    <tempDirectory>/var/tmp</jhoveHome>
+
+In the JHOVE home directory, copy the JHOVE Bourne shell driver script
+template, "jhove.tmpl", to "jhove" (or the equivalent Windows shell 
+script, "jhove_bat.tmpl" to "jhove.bat"), and set the
+JHOVE home directory, Java home directory, and Java interpreter:
+
+    JHOVE_HOME=jhove-home-directory
+    JAVA_HOME=java-home-directory
+    JAVA=java-interpreter
+
+The JAVA_HOME property should provide the absolute pathname of the Java
+runtime or SDK installation; JAVA should provide the absolute pathname of the
+Java interpreter.  For example:
+
+    JHOVE_HOME=/users/stephen/projects/jhove
+    JAVA_HOME=/usr/local/j2re1.4.1_02
+    JAVA=$JAVA_HOME/bin/java
+
+In the DOS shell driver script, jhove.bat, the equivalent three
+variables are:
+
+    SET JHOVE_HOME=jhove-home-directory
+    SET JAVA_HOME=java-home-directory
+    SET JAVA=%JAVA_HOME%\bin\java
+
+For example:
+
+    SET JHOVE_HOME="C:\Program Files\jhove"
+    SET JAVA_HOME="C:\Program Files\java\j2re1.4.1_02"
+    SET JAVA=%JAVA_HOME%\bin\java
+
+The quotation marks are necessary because of the embedded space characters.
+On Windows platforms it may also be necessary to add the Java bin subdirectory
+to the System PATH environment variable:
+
+    PATH=C:\Program Files\java\j2re1.4.1_02\bin;...
+
+(For information on setting a Windows environment variable, consult your local
+documentation or system administrator.)
+
+USAGE
+
+    java 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 used by 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)
+      -l loglevel Logging level
+      -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 or file pathname or URI of formated content
+                      stream
+
+All named modules and output handlers must be found on the Java CLASSPATH at
+the time of invocation.  The JHOVE driver script, jhove/jhove, automatically
+sets the CLASSPATH and invokes the Jhove main class:
+
+    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 [...]]
+
+The following additional programs are available, primarily for testing
+and debugging purposes.  They display a minimally processed, human-readable
+version of the contents of AIFF, GIF, JPEG, JPEG 2000, PDF, TIFF, and WAVE
+files:
+
+    java ADump  aiff-file
+    java GDump  gif-file
+    java JDump  jpeg-file
+    java J2Dump jpeg2000-file
+    java PDump  pdf-file
+    java TDump  tiff-file
+    java WDump  wave-file
+
+For convenience, the following driver scripts are also available:
+
+    adump  aiff-file
+    gdump  gif-file
+    jdump  jpeg-file
+    j2dump jpeg2000-file
+    pdump  pdf-file
+    tdump  tiff-file
+    wdump  wave-file
+
+The JHOVE Swing-based GUI interface can be invoked from a command shell from
+the jhove/bin sub-directory:
+
+    java -jar JhoveView.jar -c <configFile>
+
+where <configFile> is the pathname of the JHOVE configuration file.

data/bin/jhove-README-conf.txt

@@ -0,0 +1,63 @@
+JHOVE - JSTOR/Harvard Object Validation Environment
+Copyright 2003-2007 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)
+
+Rev. 2007-08-30
+
+Edit the configuration file, jhove.conf, and set the JHOVE home
+directory:
+
+    <jhoveHome>jhove-home-directory</jhoveHome>
+
+and temporary directory:
+
+    <tempDirectory>temporary-directory</tempDirectory>
+
+On most Unix systems, a reasonable temporary directory is "/var/tmp";
+on Windows, "C:\temp".
+
+The optional
+
+    <bufferSize>buffer-size</bufferSize>
+
+element defines the buffer size used for buffer I/O operations.
+
+The optional
+
+    <mixVersion>1.0</mixVersion>
+
+element specifies that the XML output handler should conform to the
+MIX 1.0 schema.  The default behavior is for handler output to conform
+to the MIX 0.2 schema.
+
+The optional
+
+    <sigBytes>n</sigBytes>
+
+element specifies that JHOVE modules will look for format signatures
+in the first <n> bytes of the file.  The default value is 1024.
+
+All class names must be fully qualified with their package name:
+
+    <module>
+      <class>fully-package-qualified-class-name</class>
+      <init>optional-initialization-argument</init>
+      <param>optional-invocation-argument</param>
+    </module>
+
+The optional <init> argument is passed to the module once at the time
+its class is instantiated.  See module-specific documentation for a
+description of any initialization options.
+
+The optional <param> argument is passed to the module every time it is
+invoked.  See module-specific documentation for a description of any
+invocation options.
+
+The order in which format modules are defined is important; when
+performing a format identification operation, JHOVE will search for a
+matching module in the order in which the modules are defined in the
+configuration file. In general, the modules for more generic formats
+should come later in the list. For example, the standard module ASCII
+should be defined before the UTF-8 module, since all ASCII objects
+are, by definition, UTF-8 objects, but not vice versa.

data/bin/jhove.conf

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<jhoveConfig version="1.1"
+ 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>
+ </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>
+ </module>
+ <module>
+  <class>edu.harvard.hul.ois.jhove.module.HtmlModule</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,23 @@
+#!/bin/sh
+
+JHOVE_HOME=`dirname $0`
+export JHOVE_HOME
+JAVA_HOME=/etc/alternatives/jre
+JAVA=/usr/bin/java
+
+CP=${JHOVE_HOME}/jhoveToolkit.jar:${JHOVE_HOME}/JhoveApp.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=""
+for ARG do
+    ARGS="$ARGS $ARG"
+done
+
+# Set the CLASSPATH and invoke the Java loader.
+${JAVA} -Xms128M -Xmx3000M -classpath $CP $ARGS

data/lib/jhove_service.rb

@@ -0,0 +1,94 @@
+require 'nokogiri'
+require 'pathname'
+require 'jhove_technical_metadata'
+require 'stringio'
+
+  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)
+    `#{get_jhove_command(content_dir, fileset_file)}`
+    exitcode = $?.exitstatus
+    if (exitcode != 0)
+      raise "Error when running JHOVE against #{content_dir.to_s}"
+    end
+    jhove_output.to_s
+  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] The jhove-toolkit command to be exectuted in a system call
+  def get_jhove_command(content_dir, fileset_file=nil)
+    if fileset_file.nil?
+      args = "edu.stanford.sulair.jhove.JhoveCommandLine #{content_dir.to_s}"
+    else
+      args = "edu.stanford.sulair.jhove.JhoveFileset #{content_dir.to_s} #{fileset_file.to_s}"
+    end
+    jhove_script = @bin_pathname.join('jhoveToolkit.sh').to_s
+    jhove_cmd = "#{jhove_script} #{args} > #{jhove_output.to_s}"
+    jhove_cmd
+  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

data/lib/tasks/yard.rake

@@ -0,0 +1,31 @@
+desc "Generate RDoc"
+task :doc => ['doc:generate']
+
+namespace :doc do
+  project_root = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+  doc_destination = File.join(project_root, 'doc')
+
+  begin
+    require 'yard'
+    require 'yard/rake/yardoc_task'
+
+    YARD::Rake::YardocTask.new(:generate) do |yt|
+      yt.files   =  Dir.glob(File.join(project_root, 'lib', '*.rb')) + 
+                    ['-'] +
+                   [ File.join(project_root, 'LICENSE.rdoc') ]
+                   
+      yt.options = ['--output-dir', doc_destination, '--hide-void-return']
+    end
+  rescue LoadError
+    desc "Generate YARD Documentation"
+    task :generate do
+      abort "Please install the YARD gem to generate rdoc."
+    end
+  end
+
+  desc "Remove generated documentation"
+  task :clean do
+    rm_r doc_destination if File.exists?(doc_destination)
+  end
+
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: jhove-service
+version: !ruby/object:Gem::Version
+  version: 1.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Richard Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.3.1
+- !ruby/object:Gem::Dependency
+  name: equivalent-xml
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Generates JHOVE output and/or technicalMetadata
+email:
+- rnanders@stanford.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/extension-mimetype.conf
+- bin/jhove-README-1st.txt
+- bin/jhove-README-conf.txt
+- bin/jhove.conf
+- bin/JhoveApp.jar
+- bin/jhoveToolkit.jar
+- bin/jhoveToolkit.sh
+- lib/jhove_service.rb
+- lib/jhove_technical_metadata.rb
+- lib/tasks/yard.rake
+- LICENSE.rdoc
+- README.rdoc
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 4252808025718583470
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Generates JHOVE output and/or technicalMetadata
+test_files: []
+has_rdoc: