libis-format 0.9.49 → 0.9.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47b210d27058d7ee640e2435f952d8dc58537deb
-  data.tar.gz: 531d8103bea3b028c4d51f10aa793e8488b03df9
+  metadata.gz: 495a17a421b0c23121d7e38feb91755b0dbfdfd0
+  data.tar.gz: e6b9687dca16d98c3e1c67dc6d89f90e20989acc
 SHA512:
-  metadata.gz: 2288f2bc2962c96fdaf361c9db9da137c98acbe084962a0fa47f503df8fdc030dc8600f5c62d98bac6ad8e2a6f89f002e22a1a5c4f33a3c2af189a137d583299
-  data.tar.gz: 48a6446cc762623fac7403c70a6c80b4fedab6b409973653bb6a2038180d2dd7e85c1ca0e73b17a1fb7a0ea52c50c4c5371528b432161c8a5b4b6b7718109c7d
+  metadata.gz: f6c5fb037d0d5de37a0020d043401335db1874045f945981cab6c5edf9b4bb2cad212cde590dbdfa210740683301f0e5e9e17af838d01a05d42a499736825e81
+  data.tar.gz: dd65ca5bc986263ac03be6812bdab42a939746bc5c23182d92123a66c44d4e2f0cda0b6a80b07caaf027a5f523ec4d46e7ad826ab9500cec72820a54deffc0ac

data/lib/libis/format/config.rb

@@ -24,6 +24,21 @@ module Libis
     Config[:type_database] = File.join(Libis::Format::DATA_DIR, 'types.yml')
     Config[:raw_audio_convert_cmd] = 'sox %s -e signed -b 16 -t wav %s rate %d channels %d'
     Config[:watermark_font] = '/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf'
+    Config[:timeouts] = {
+        droid: 5 * 60,
+        ffmpeg: 5 * 60,
+        fido: 5 * 60,
+        file_tool: 5 * 60,
+        fop: 5 * 60,
+        identification_tool: 5 * 60,
+        office_to_pdf: 5 * 60,
+        pdf_copy: 5 * 60,
+        pdf_merge: 5 * 60,
+        pdf_optimizer: 5 * 60,
+        pdf_split: 5 * 60,
+        pdf_to_pdfa: 5 * 60,
+        pdfa_validator: 5 * 60,
+    }
 
   end
 end

data/lib/libis/format/converter/xslt_converter.rb

@@ -1,5 +1,3 @@
-require 'nokogiri'
-
 require_relative 'base'
 
 module Libis
@@ -29,61 +27,71 @@ module Libis
             return nil
           end
 
-          doc = nil
-          begin
-            doc = Nokogiri::XML(File.read(source)) do |config|
-              config.options = Nokogiri::XML::ParseOptions::STRICT | Nokogiri::XML::ParseOptions::NOBLANKS
-            end
-          rescue Nokogiri::XML::SyntaxError => e
-            if e.fatal? || e.error?
-              error "Error parsing XML input '#{source}': #{e.messsage} @ #{e.backtrace[0]}"
-              return nil
-            end
-          end
-
           unless @options[:xsl_file]
             error 'No xsl_file supplied'
             return nil
           end
 
-          file = @options[:xsl_file]
+          FileUtils.mkpath(File.dirname(target))
 
-          unless File.file?(file) && File.exist?(file) && File.readable?(file)
-            error "XSL file '#{@options[:xsl_file]}' does not exist or is not readable"
-            return nil
-          end
+          if RUBY_PLATFORM == "java"
+            require 'saxon-xslt'
+            xsl = Saxon.XSLT(File.open(@options[:xsl_file]))
+            xml = Saxon.XML(File.open(source))
+            result = xsl.transform(xml)
+            File.open(target, 'w') {|f| f.write(result.to_s)}
+          else
+            require 'nokogiri'
+
+            doc = nil
+            begin
+              doc = Nokogiri::XML(File.read(source)) do |config|
+                config.options = Nokogiri::XML::ParseOptions::STRICT | Nokogiri::XML::ParseOptions::NOBLANKS
+              end
+            rescue Nokogiri::XML::SyntaxError => e
+              if e.fatal? || e.error?
+                error "Error parsing XML input '#{source}': #{e.messsage} @ #{e.backtrace[0]}"
+                return nil
+              end
+            end
 
-          FileUtils.mkpath(File.dirname(target))
+            file = @options[:xsl_file]
 
-          xsl = nil
+            unless File.file?(file) && File.exist?(file) && File.readable?(file)
+              error "XSL file '#{@options[:xsl_file]}' does not exist or is not readable"
+              return nil
+            end
 
-          begin
-            fp = File.open(file, 'r')
-            xsl = Nokogiri::XSLT(fp) do |config|
-              config.options = Nokogiri::XML::ParseOptions::STRICT | Nokogiri::XML::ParseOptions::NOBLANKS
+            xsl = nil
+
+            begin
+              fp = File.open(file, 'r')
+              xsl = Nokogiri::XSLT(fp) do |config|
+                config.options = Nokogiri::XML::ParseOptions::STRICT | Nokogiri::XML::ParseOptions::NOBLANKS
+              end
+            rescue Nokogiri::XML::SyntaxError => e
+              if e.fatal? || e.error?
+                error "Error parsing XSL input '#{file}': #{e.message} @ #{e.backtrace[0]}"
+                return nil
+              end
+            ensure
+              fp.close
             end
-          rescue Nokogiri::XML::SyntaxError => e
-            if e.fatal? || e.error?
-              error "Error parsing XSL input '#{file}': #{e.message} @ #{e.backtrace[0]}"
+
+            begin
+              target_xml = xsl.transform(doc)
+              fp = File.open(target, 'w')
+              fp.write(target_xml)
+            rescue Exception => e
+              error "Error transforming '#{source}' with '#{file}': #{e.message} @ #{e.backtrace[0]}"
               return nil
+            ensure
+              fp.close unless fp.nil? or fp.closed?
             end
-          ensure
-            fp.close
-          end
 
-          begin
-            target_xml = xsl.transform(doc)
-            fp = File.open(target, 'w')
-            fp.write(target_xml)
-          rescue Exception => e
-            error "Error transforming '#{source}' with '#{file}': #{e.message} @ #{e.backtrace[0]}"
-            return nil
-          ensure
-            fp.close
+            target
           end
 
-          target
-
         end
 
       end

data/lib/libis/format/tool/droid.rb

@@ -74,8 +74,16 @@ module Libis
               '-p', profile,
               '-q'
           ]
-          result = Libis::Tools::Command.run(Libis::Format::Config[:droid_path], *args)
-          raise RuntimeError, "DROID report errors: #{result[:err].join("\n")}" unless result[:status] == 0
+          timeout = Libis::Format::Config[:timeouts][:droid]
+          result = Libis::Tools::Command.run(
+              Libis::Format::Config[:droid_path], *args,
+              timeout: timeout,
+              kill_after: timeout * 2
+          )
+          result[:err].select! {|x| x =~ /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} ERROR /}
+          raise RuntimeError, "#{self.class} report took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} report errors: #{result[:err].join("\n")}" unless result[:err].empty?
+
           File.delete profile
         end
 
@@ -83,10 +91,18 @@ module Libis
           args = []
           files = (file_or_list.is_a?(Array)) ? file_or_list.map(&:escape_for_string) : [file_or_list.escape_for_string]
           files.each {|file| args << '-a' << file}
-          args << '-p' << profile << '-q'
+          args << '-q'
+          args << '-p' << profile
           args << '-R' if recursive
-          result = Libis::Tools::Command.run(Libis::Format::Config[:droid_path], *args)
-          raise RuntimeError, "DROID profile errors: #{result[:err].join("\n")}" unless result[:status] == 0
+          timeout = Libis::Format::Config[:timeouts][:droid]
+          result = Libis::Tools::Command.run(
+              Libis::Format::Config[:droid_path], *args,
+              timeout: timeout,
+              kill_after: timeout * 2
+          )
+          result[:err].select! {|x| x =~ /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} ERROR /}
+          raise RuntimeError, "#{self.class} profile took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} profile errors: #{result[:err].join("\n")}" unless result[:err].empty?
         end
 
         def profile_file_name

data/lib/libis/format/tool/ffmpeg.rb

@@ -25,12 +25,17 @@ module Libis
           opts += options[:filter] unless options[:filter].empty?
           opts += options[:output] unless options[:output].empty?
           opts << target
-          result = Libis::Tools::Command.run(Libis::Format::Config[:ffmpeg_path], *opts)
 
-          unless result[:status] == 0
-            error "FFMpeg errors: #{(result[:err] + result[:out]).join("\n")}"
-            return false
-          end
+          timeout = Libis::Format::Config[:timeouts][:ffmpeg]
+          result = Libis::Tools::Command.run(
+              Libis::Format::Config[:ffmpeg_path], *opts,
+              timeout: timeout,
+              kill_after: timeout * 2
+          )
+
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0
+
           warn "FFMpeg warnings: #{(result[:err] + result[:out]).join("\n")}" unless result[:err].empty?
 
           result[:out]

data/lib/libis/format/tool/fido.rb

@@ -74,17 +74,23 @@ module Libis
           args << '-q'
 
           # Run command and capture results
-          fido = ::Libis::Tools::Command.run(Libis::Format::Config[:fido_path], *args)
+          timeout = Libis::Format::Config[:timeouts][:fido]
+          result = ::Libis::Tools::Command.run(
+              Libis::Format::Config[:fido_path], *args,
+              timeout: timeout,
+              kill_after: timeout * 2
+          )
 
           # Log warning if needed
-          raise RuntimeError, "Fido errors: #{fido[:err].join("\n")}" unless fido[:err].empty?
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
 
           # Parse output (CSV) text into array and return result
           keys = [:status, :time, :puid, :format_name, :format_version, :filesize, :filepath, :mimetype, :matchtype]
-          result = CSV.parse(fido[:out].join("\n"))
+          data = CSV.parse(result[:out].join("\n"))
                        .map {|a| Hash[keys.zip(a)]}
                        .select {|a| a[:status] == 'OK'}
-          result.each do |r|
+          data.each do |r|
             r.delete(:time)
             r.delete(:status)
             r.delete(:filesize)

data/lib/libis/format/tool/file_tool.rb

@@ -59,13 +59,18 @@ module Libis
           opts << filename.escape_for_string if filename
 
           # Run the UNIX file command and capture the results
-          file_tool = ::Libis::Tools::Command.run('file', *opts)
-
-          raise RuntimeError, "File command errors: #{file_tool[:err].join("\n")}" unless file_tool[:err].empty?
+          timeout = Libis::Format::Config[:timeouts][:file_tool]
+          result = ::Libis::Tools::Command.run(
+              'file', *opts,
+              timeout: timeout,
+              kill_after: timeout * 2
+          )
 
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
 
           # Parse output text into array and return result
-          file_tool[:out].map do |line|
+          result[:out].map do |line|
             r = line.split(/:\s+/)
             {filepath: r[0], mimetype: r[1], matchtype: 'magic', tool: :file}
           end

data/lib/libis/format/tool/fop_pdf.rb

@@ -23,14 +23,20 @@ module Libis
             # TODO: import library and execute in current VM. For now do exactly as in MRI.
           end
 
-          Libis::Tools::Command.run(
+          timeout = Libis::Format::Config[:timeouts][:fop]
+          result = Libis::Tools::Command.run(
               Libis::Format::Config[:java_path],
               "-Dfop.home=#{File.dirname(Libis::Format::Config[:fop_jar])}",
               '-jar', Libis::Format::Config[:fop_jar],
               '-fo', xml,
-              '-pdf', target
+              '-pdf', target,
+              timeout: timeout,
+              kill_after: timeout * 2
           )
 
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0
+
         end
       end
 

data/lib/libis/format/tool/office_to_pdf.rb

@@ -31,19 +31,22 @@ module Libis
 
           export_filter = options[:export_filter] || 'pdf'
 
+          timeout = Libis::Format::Config[:timeouts][:office_to_pdf]
           result = Libis::Tools::Command.run(
               Libis::Format::Config[:soffice_path], '--headless',
               '--convert-to', export_filter,
-              '--outdir', workdir, src_file
+              '--outdir', workdir, src_file,
+              timeout: timeout,
+              kill_after: timeout * 2
           )
 
-          unless result[:status] == 0
-            warn "PdfConvert errors: #{(result[:err] + result[:out]).join("\n")}"
-            return false
-          end
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
 
           FileUtils.copy tgt_file, target, preserve: true
-          FileUtils.rmtree workdir
+
+        ensure
+          FileUtils.rmtree workdir rescue nil
 
           result[:out]
         end

data/lib/libis/format/tool/pdf_copy.rb

@@ -23,15 +23,21 @@ module Libis
             # TODO: import library and execute in current VM. For now do exactly as in MRI.
           end
 
-          Libis::Tools::Command.run(
+          timeout = Libis::Format::Config[:timeouts][:pdf_copy]
+          result = Libis::Tools::Command.run(
               Libis::Format::Config[:java_path],
               '-cp', Libis::Format::Config[:pdf_tool],
               'CopyPdf',
               '--file_input', source,
               '--file_output', target,
-              *options
+              *options,
+              timeout: timeout,
+              kill_after: timeout * 2
           )
 
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
+
         end
       end
 

data/lib/libis/format/tool/pdf_merge.rb

@@ -24,15 +24,21 @@ module Libis
             # TODO: import library and execute in current VM. For now do exactly as in MRI.
           end
 
-          Libis::Tools::Command.run(
+          timeout = Libis::Format::Config[:timeouts][:pdf_merge]
+          result = Libis::Tools::Command.run(
               Libis::Format::Config[:java_path],
               '-cp', Libis::Format::Config[:pdf_tool],
               'MergePdf',
               '--file_output', target,
               *options,
               *source,
+              timeout: timeout,
+              kill_after: timeout * 2
           )
 
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
+
         end
       end
 

data/lib/libis/format/tool/pdf_optimizer.rb

@@ -19,7 +19,8 @@ module Libis
 
         def run(source, target, quality)
 
-          Libis::Tools::Command.run(
+          timeout = Libis::Format::Config[:timeouts][:pdf_optimizer]
+          result = Libis::Tools::Command.run(
               'gs',
               '-sDEVICE=pdfwrite',
               '-dCompatibilityLevel=1.4',
@@ -27,9 +28,14 @@ module Libis
               '-dNOPAUSE',
               '-dBATCH',
               "-sOutputFile=#{target}",
-              "#{source}"
+              "#{source}",
+              timeout: timeout,
+              kill_after: timeout * 2
           )
 
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
+
         end
       end
 

data/lib/libis/format/tool/pdf_split.rb

@@ -23,15 +23,21 @@ module Libis
             # TODO: import library and execute in current VM. For now do exactly as in MRI.
           end
 
-          Libis::Tools::Command.run(
+          timeout = Libis::Format::Config[:timeouts][:pdf_split]
+          result = Libis::Tools::Command.run(
               Libis::Format::Config[:java_path],
               '-cp', Libis::Format::Config[:pdf_tool],
               'SplitPdf',
               '--file_input', source,
               '--file_output', target,
-              *options
+              *options,
+              timeout: timeout,
+              kill_after: timeout * 2
           )
 
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
+
         end
       end
 

data/lib/libis/format/tool/pdf_to_pdfa.rb

@@ -37,6 +37,7 @@ module Libis
                 gsub('[** Fill in ICC reference name **]', icc_info[:icc_ref])
           end
 
+          timeout = Libis::Format::Config[:timeouts][:pdf_to_pdfa]
           result = Libis::Tools::Command.run(
               Libis::Format::Config[:ghostscript_path],
               '-dBATCH', '-dNOPAUSE', '-dNOOUTERSAVE',
@@ -46,9 +47,14 @@ module Libis
               "-sOutputICCProfile=#{icc_file}",
               '-o', File.absolute_path(target),
               def_filename,
-              source
+              source,
+              timeout: timeout,
+              kill_after: timeout * 2
           )
 
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
+
           FileUtils.rm [icc_file, def_filename].compact, force: true
 
           unless Format::Tool::PdfaValidator.run(target)

data/lib/libis/format/tool/pdfa_validator.rb

@@ -21,6 +21,7 @@ module Libis
 
           src_file = File.absolute_path(source)
 
+          timeout = Libis::Format::Config[:timeouts][:pdfa_validator]
           if (pdfa = Libis::Format::Config[:pdfa_path])
             # Keep it clean: tool generates fontconfig/ cache dir in current working dir
             previous_wd = Dir.getwd
@@ -31,9 +32,14 @@ module Libis
                 '--noxml',
                 '--level', 'B',
                 '--verb', '0',
-                src_file
+                src_file,
+                timeout: timeout,
+                kill_after: timeout * 2
             )
 
+            raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+            raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
+
             Dir.chdir(previous_wd)
 
             unless result[:out].any? {|line| line =~ /^VLD-\[PASS\]/}
@@ -46,8 +52,13 @@ module Libis
             result = Libis::Tools::Command.run(
                 Libis::Format::Config[:java_path],
                 '-jar', jar,
-                src_file
+                src_file,
+                timeout: timeout,
+                kill_after: timeout * 2
             )
+            raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+            raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:err].empty?
+
             unless result[:status] == 0
               warn "Validator failed to validate the PDF file '%s' against PDF/A-1B constraints:\n%s", source,
                    result[:out].join("\n")

data/lib/libis/format/version.rb

@@ -1,5 +1,5 @@
 module Libis
   module Format
-    VERSION = '0.9.49'
+    VERSION = '0.9.50'
   end
 end

data/libis-format.gemspec

@@ -27,6 +27,11 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3.1'
   spec.add_development_dependency 'awesome_print'
   spec.add_development_dependency 'equivalent-xml', '~> 0.5'
+  if spec.platform == Gem::Platform::JAVA
+    spec.add_development_dependency 'saxon-xslt'
+  else
+    spec.add_development_dependency 'nokogiri'
+  end
 
   spec.add_runtime_dependency 'libis-tools', '~> 0.9.57'
   spec.add_runtime_dependency 'os', '= 0.9.6'

data/spec/converter_fop_spec.rb

@@ -21,16 +21,15 @@ describe 'Converters' do
     let(:data_dir) {File.join(file_dir, 'data', 'xml')}
 
     it 'converts XML-FO to PDF' do
-      src_file = File.join data_dir, '134476_fo.XML'
-      tgt_file = File.join '', 'tmp', '134476_ead.pdf'
-      cmp_file = File.join data_dir, '134476_ead.pdf'
-      FileUtils.remove tgt_file, force: true
-      FileUtils.mkdir_p File.dirname(tgt_file)
-      result = converter.convert src_file, tgt_file, :PDF
-      expect(result).to eq tgt_file
-      # tgt = Nokogiri::XML(File.read(tgt_file))
-      # cmp = Nokogiri::XML(File.read(cmp_file))
-      # expect(tgt.root).to be_equivalent_to(cmp.root).respecting_element_order
+      if File.exist?(Libis::Format::Config[:fop_jar])
+        src_file = File.join data_dir, '134476_fo.XML'
+        tgt_file = File.join '', 'tmp', '134476_ead.pdf'
+        cmp_file = File.join data_dir, '134476_ead.pdf'
+        FileUtils.remove tgt_file, force: true
+        FileUtils.mkdir_p File.dirname(tgt_file)
+        result = converter.convert src_file, tgt_file, :PDF
+        expect(result).to eq tgt_file
+      end
     end
 
   end

data/spec/converter_repository_spec.rb

@@ -13,7 +13,7 @@ describe 'Converters' do
   context 'Repository' do
 
     it 'loads all converters' do
-      expect(repository.get_converters.size).to eq 6
+      expect(repository.get_converters.size).to eq 8
       # noinspection RubyResolve
       expect(repository.get_converters.map(&:to_s)).to include 'Libis::Format::Converter::ImageConverter'
       # noinspection RubyResolve
@@ -26,6 +26,10 @@ describe 'Converters' do
       expect(repository.get_converters.map(&:to_s)).to include 'Libis::Format::Converter::AudioConverter'
       # noinspection RubyResolve
       expect(repository.get_converters.map(&:to_s)).to include 'Libis::Format::Converter::VideoConverter'
+      # noinspection RubyResolve
+      expect(repository.get_converters.map(&:to_s)).to include 'Libis::Format::Converter::XsltConverter'
+      # noinspection RubyResolve
+      expect(repository.get_converters.map(&:to_s)).to include 'Libis::Format::Converter::FopPdfConverter'
     end
 
     it 'creates simple converter chain' do

data/spec/data/xml/ead2fo_pdf.xsl

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="windows-1252"?>
-<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:fo="http://www.w3.org/1999/XSL/Format">
+<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:fo="http://www.w3.org/1999/XSL/Format">
 	<xsl:strip-space elements="*"/>
 	<xsl:output method="xml" encoding="UTF-8" indent="yes"/>
 	<xsl:include href="header_nolink_pdf.xsl"/>
 	<!-- Creates the body of the finding aid.-->
 	<xsl:template match="/ead">
-		<fo:root>
+		<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
 			<fo:layout-master-set>
 				<fo:simple-page-master master-name="pages" page-width="21cm" page-height="29.7cm" 
 					margin-top="1cm" margin-bottom="1cm"
@@ -437,10 +437,10 @@
 			<fo:list-item-label end-indent="label-end()">
 				<fo:block font-family="Times">
 					<xsl:variable name="value-attr">
-					<xsl:choose>
-						<xsl:when test="../@start"><xsl:number value="position() + ../@start - 1"/></xsl:when>
-						<xsl:otherwise><xsl:number value="position()"/></xsl:otherwise>
-					</xsl:choose>
+						<xsl:choose>
+							<xsl:when test="../@start"><xsl:number value="position() + ../@start - 1"/></xsl:when>
+							<xsl:otherwise><xsl:number value="position()"/></xsl:otherwise>
+						</xsl:choose>
 					</xsl:variable>
 				</fo:block>
 			</fo:list-item-label>

data/spec/data/xml/header_nolink_pdf.xsl

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="windows-1252"?>
-<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 	
 <xsl:variable name="REC_ID" select="ead/eadheader/eadid/@identifier"/>
 <xsl:variable name="TITLE_HEADER" select="ead/eadheader[1]/filedesc[1]/titlestmt[1]/titleproper[1]"/>	
@@ -117,4 +117,4 @@
 	</xsl:variable>
 
 
-</xsl:stylesheet>
+</xsl:stylesheet>

data/spec/data/xml/scope_eadToHTML.xsl

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="windows-1252"?>
 <xsl:stylesheet xmlns="http://www.w3.org/1999/xhtml" 
-    xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="2.0"
     xmlns:ead="urn:isbn:1-931666-22-9"
     xmlns:ns2="http://www.w3.org/1999/xlink">
     <xsl:strip-space elements="*"/>