libis-format 1.0.4 → 2.0.2

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

@@ -15,7 +15,7 @@ module Libis
         end
 
         def self.output_types(format = nil)
-          return [] unless input_types.include?(format)
+          return [] unless input_types.include?(format) if format
           [:JP2]
         end
 
@@ -91,7 +91,7 @@ module Libis
 
 
           Libis::Tools::Command.run(
-              Libis::Format::Config[:j2kdriver],
+              Libis::Format::Config[:j2k_cmd],
               '--input-file-name', source,
               '--set-output-type', 'JP2',
               *options,

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

@@ -3,7 +3,7 @@
 require_relative 'base'
 
 require 'libis/format/tool/office_to_pdf'
-require 'libis/format/type_database'
+require 'libis/format/library'
 
 module Libis
   module Format
@@ -32,7 +32,7 @@ module Libis
         end
 
         def self.output_types(format = nil)
-          return [] unless input_types.include?(format)
+          return [] unless input_types.include?(format) if format
           [:PDF]
         end
 

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

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+require_relative 'base'
+
+require 'libis/format/tool/pdf_merge'
+
+module Libis
+  module Format
+    module Converter
+
+      # noinspection DuplicatedCode
+      class PdfAssembler < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF]
+        end
+
+        def self.category
+          :assembler
+        end
+
+        def pdf_assemnble(_)
+          #force usage of this converter
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          result = if source.is_a? Array
+                     assemble(source, target)
+                   elsif File.directory?(source)
+                     source_list = Dir[File.join(source, '**', '*')].reject {|p| File.directory? p}
+                     assemble(source_list, target)
+                   else
+                     assemble([source], target)
+                   end
+          return nil unless result
+
+          result
+        end
+
+        private
+
+        def assemble(source, target)
+
+          result = Libis::Format::Tool::PdfMerge.run(source, target)
+
+          unless result[:err].empty?
+            error("PdfMerge encountered errors:\n%s", result[:err].join(join("\n")))
+            return nil
+          end
+
+          target
+        end
+
+      end
+
+    end
+
+  end
+end

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

@@ -2,15 +2,13 @@
 
 require_relative 'base'
 
-require 'libis/tools/extend/hash'
-require 'libis/format/tool/pdf_copy'
-require 'libis/format/tool/pdf_to_pdfa'
-require 'libis/format/tool/pdf_optimizer'
+require 'libis/format/tool/pdf_metadata'
 
 module Libis
   module Format
     module Converter
 
+      # noinspection DuplicatedCode
       class PdfConverter < Libis::Format::Converter::Base
 
         def self.input_types
@@ -18,151 +16,29 @@ module Libis
         end
 
         def self.output_types(format = nil)
-          return [] unless input_types.include?(format)
-          [:PDF, :PDFA]
-        end
-
-        def pdf_convert(_)
-          #force usage of this converter
-        end
-
-        # Set metadata for Pdf file
-        #
-        # valid metadata keys are):
-        #       - title
-        #       - author
-        #       - creator
-        #       - keywords
-        #       - subject
-        #
-        # @param [Hash] values list of metadata values to set
-        def metadata(values = {})
-          values.key_strings_to_symbols!
-          values.each do |k, v|
-            next unless [:title, :author, :creator, :keywords, :subject].include?(k)
-            @options["md_#{k}"] = v
-          end
-        end
-
-        # Select a partial list of pages
-        # @param [String] selection as described in com.itextpdf.text.pdf.SequenceList: [!][o][odd][e][even]start-end
-        def range(selection)
-          @options[:ranges] = selection
-        end
-
-        # Create or use a watermark image.
-        #
-        # The watermark options are (use symbols):
-        #     - text: text to create a watermark from
-        #     - file: watermark image to use
-        #     - rotation: rotation of the watermark text (in degrees; integer number)
-        #     - size: font size of the watermark text
-        #     - opacity: opacity of the watermark (fraction 0.0 - 1.0)
-        #     - gap: size of the gap between watermark instances. Integer value is absolute size in points (1/72 inch). Fractions are percentage of widht/height.
-        # If both options are given, the file will be used as-is if it exists and is a valid image file. Otherwise the
-        # file will be created or overwritten with a newly created watermark image.
-        #
-        # The created watermark file will be a PNG image with transparent background containing the supplied text
-        # slanted by 30 degrees counter-clockwise.
-        #
-        # @param [Hash] options Hash of options for watermark creation.
-        def watermark(options = {})
-          options.key_strings_to_symbols!
-          if options[:file] && File.exist?(options[:file])
-            @options['wm_image'] = options[:file]
-          else
-            @options['wm_text'] = (options[:text] || '© LIBIS').split('\n')
-            @options['wm_text_rotation'] = options[:rotation] if options[:rotation]
-            @options['wm_font_size'] = options[:size] if options[:size]
-          end
-          @options['wm_opacity'] = options[:opacity] || '0.3'
-          @options['wm_gap_ratio'] = options[:gap] if options[:gap].to_s =~ /^\s*(0+\.\d+|1\.0+)\s*$/
-          @options['wm_gap_size'] = options[:gap] if options[:gap].to_s =~ /^\s*\d+\s*$/
-        end
-
-        # Optimize the PDF
-        #
-        # This reduces the graphics quality to a level in order to limit file size. This option relies on the
-        # presence of ghostscript and takes one argument: the quality level. It should be one of:
-        #
-        # - 0 : lowest quality (Acrobat Distiller 'Screen Optimized' equivalent)
-        # - 1 : medium quality (Acrobat Distiller 'eBook' equivalent)
-        # - 2 : good quality
-        # - 3 : high quality (Acrobat Distiller 'Print Optimized' equivalent)
-        # - 4 : highest quality (Acrobat Distiller 'Prepress Optimized' equivalent)
-        #
-        # Note that the optimization is intended to be used with PDF's containing high-resolution images.
-        #
-        # @param [Integer] setting quality setting. [0-4]
-        def optimize(setting = 1)
-          @options['optimize'] = %w(screen ebook default printer prepress)[setting] if (0..4) === setting
+          return [] unless input_types.include?(format) if format
+          [:PDFA]
         end
 
         def convert(source, target, format, opts = {})
           super
 
-          result = nil
-
-          if (quality = @options.delete('optimize'))
-            result = optimize_pdf(source, target, quality)
-            return nil unless result
-            source = result
-          end
-
-          unless @options.empty?
-            result = convert_pdf(source, target)
-            return nil unless result
-            source = result
-          end
-
-          if format == :PDFA and source
-            result = pdf_to_pdfa(source, target)
-          end
+          result = pdf_to_pdfa(source, target)
+          return nil unless result
 
           result
 
         end
 
-        def optimize_pdf(source, target, quality)
-
-          using_temp(target) do |tmpname|
-            result = Libis::Format::Tool::PdfOptimizer.run(source, tmpname, quality)
-            unless result[:status] == 0
-              error("Pdf optimization encountered errors:\n%s", (result[:err] + result[:out]).join('\n'))
-              next nil
-            end
-            tmpname
-          end
-        end
-
-        def convert_pdf(source, target)
-
-          using_temp(target) do |tmpname|
-            result = Libis::Format::Tool::PdfCopy.run(
-                source, tmpname,
-                @options.map { |k, v|
-                  if v.nil?
-                    nil
-                  else
-                    ["--#{k}", (v.is_a?(Array) ? v : v.to_s)]
-                  end }.flatten
-            )
-            unless result[:err].empty?
-              error("Pdf conversion encountered errors:\n%s", result[:err].join('\n'))
-              next nil
-            end
-            tmpname
-          end
-
-        end
-
         def pdf_to_pdfa(source, target)
 
           using_temp(target) do |tmpname|
             result = Libis::Format::Tool::PdfToPdfa.run source, tmpname
-            unless result[:status] == 0
-              error("Pdf/A conversion encountered errors:\n%s", result[:err].join('\n'))
+            if result[:status] != 0
+              error("Pdf/A conversion encountered errors:\n%s", result[:err].join("\n"))
               next nil
+            else
+              warn("Pdf/A conversion warnings:\n%s", result[:err].join("\n")) unless result[:err].empty?
             end
             tmpname
           end

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

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+require_relative 'base'
+
+require 'libis/format/tool/pdf_metadata'
+
+module Libis
+  module Format
+    module Converter
+
+      # noinspection DuplicatedCode
+      class PdfMetadata < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF]
+        end
+
+        def title(v)
+          @options[:title] = v.blank? ? nil : v
+        end
+
+        def author(v)
+          @options[:author] = v.blank? ? nil : v
+        end
+
+        def creator(v)
+          @options[:creator] = v.blank? ? nil : v
+        end
+
+        def keywords(v)
+          @options[:keywords] = v.blank? ? nil : v
+        end
+
+        def subject(v)
+          @options[:subject] = v.blank? ? nil : v
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          result = nil
+
+          unless @options.empty?
+            result = convert_pdf(source, target)
+            return nil unless result
+          end
+
+          result
+
+        end
+
+        def convert_pdf(source, target)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfMetadata.run(
+                source, tmpname,
+                @options.map {|k, v|
+                  if v.nil?
+                    nil
+                  else
+                    ["--#{k}", v]
+                  end}.compact.flatten
+            )
+            unless result[:err].empty?
+              error("Pdf conversion encountered errors:\n%s", result[:err].join(join("\n")))
+              next nil
+            end
+            tmpname
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require_relative 'base'
+
+require 'libis/format/tool/pdf_optimizer'
+
+module Libis
+  module Format
+    module Converter
+
+      class PdfOptimizer < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF]
+        end
+
+        def pdf_optimize(_)
+          #force usage of this converter
+        end
+
+        # Optimize the PDF
+        #
+        # This reduces the graphics quality to a level in order to limit file size. This option relies on the
+        # presence of ghostscript and takes one argument: the quality level. It should be one of:
+        #
+        # - 0 : lowest quality (Acrobat Distiller 'Screen Optimized' equivalent)
+        # - 1 : medium quality (Acrobat Distiller 'eBook' equivalent)
+        # - 2 : good quality
+        # - 3 : high quality (Acrobat Distiller 'Print Optimized' equivalent)
+        # - 4 : highest quality (Acrobat Distiller 'Prepress Optimized' equivalent)
+        #
+        # Note that the optimization is intended to be used with PDF's containing high-resolution images.
+        #
+        # @param [Integer] setting quality setting. [0-4]
+        def quality(setting = 1)
+          @quality = %w(screen ebook default printer prepress)[setting] if (0..4) === setting
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+           optimize_pdf(source, target, @quality || 'ebook')
+
+        end
+
+        def optimize_pdf(source, target, quality)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfOptimizer.run(source, tmpname, quality)
+            unless result[:status] == 0
+              error("Pdf optimization encountered errors:\n%s", (result[:err] + result[:out]).join("\n"))
+              next nil
+            end
+            tmpname
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# encoding: utf-8
+require 'securerandom'
+
+require_relative 'base'
+require 'libis/format/tool/pdf_protect'
+
+module Libis
+  module Format
+    module Converter
+
+      RANDOM_CHARS = [('a'..'z'), ('A'..'Z'), ('0'..'9')].map(&:to_a).flatten
+
+      # noinspection DuplicatedCode
+      class PdfProtecter < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF, :PDFA]
+        end
+
+        def pdf_protect(_)
+          #force usage of this converter
+        end
+
+        def initialize
+          super
+          @options[:edit_password] = SecureRandom.urlsafe_base64(31)
+        end
+
+        def edit_password(pwd)
+          @options[:edit_password] = pwd
+        end
+
+        def open_password(pwd)
+          @options[:open_password] = pwd
+        end
+
+        def assist(v)
+          @flags[:assist] = !!v
+        end
+
+        def copy(v)
+          @flags[:copy] = !!v
+        end
+
+        def print(v)
+          @flags[:print] = !!v
+        end
+
+        def comments(v)
+          @flags[:comments] = !!v
+        end
+
+        def fillin(v)
+          @flags[:fillin] = !!v
+        end
+
+        def manage(v)
+          @flags[:manage] = !!v
+        end
+
+        def edit(v)
+          @flags[:edit] = !!v
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          result = nil
+
+          unless @options.empty?
+            result = convert_pdf(source, target)
+            return nil unless result
+            source = result
+          end
+
+          if format == :PDFA and source
+            result = pdf_to_pdfa(source, target)
+          end
+
+          result
+
+        end
+
+        OPTIONS_TABLE = {
+          edit_password: 'edit-password',
+          open_password: 'open-password',
+          fillin: 'fill-in',
+        }
+
+        def convert_pdf(source, target)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfProtect.run(
+              source, tmpname,
+              [
+                @options.map { |k, v|
+                  if v.nil?
+                    nil
+                  else
+                    k = OPTIONS_TABLE[k] || k
+                    ["--#{k}", v]
+                  end
+                },
+                @flags.map { |k, v|
+                  if !v
+                    nil
+                  else
+                    k = OPTIONS_TABLE[k] || k
+                    "--#{k}"
+                  end
+                }
+              ].compact.flatten
+            )
+            unless result[:err].empty?
+              error("Pdf conversion encountered errors:\n%s", result[:err].join(join("\n")))
+              next nil
+            end
+            tmpname
+          end
+
+        end
+
+        def pdf_to_pdfa(source, target)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfToPdfa.run source, tmpname
+            if result[:status] != 0
+              error("Pdf/A conversion encountered errors:\n%s", result[:err].join("\n"))
+              next nil
+            else
+              warn("Pdf/A conversion warnings:\n%s", result[:err].join("\n")) unless result[:err].empty?
+            end
+            tmpname
+          end
+
+        end
+
+      end
+
+    end
+  end
+end