libis-format 1.2.9 → 1.3.2

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

@@ -1,9 +1,9 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require_relative 'base'
 
 require 'libis/tools/extend/hash'
-require 'libis/format/tool/pdf_copy'
+require 'libis/format/tool/pdf_tool'
 require 'libis/format/tool/pdf_to_pdfa'
 require 'libis/format/tool/pdfa_validator'
 require 'libis/format/tool/pdf_optimizer'
@@ -11,20 +11,19 @@ require 'libis/format/tool/pdf_optimizer'
 module Libis
   module Format
     module Converter
-
       class PdfConverter < Libis::Format::Converter::Base
-
         def self.input_types
           [:PDF]
         end
 
         def self.output_types(format = nil)
           return [] unless input_types.include?(format)
-          [:PDF, :PDFA]
+
+          %i[PDF PDFA]
         end
 
         def pdf_convert(_)
-          #force usage of this converter
+          # force usage of this converter
         end
 
         # Set metadata for Pdf file
@@ -40,15 +39,15 @@ module Libis
         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
+            next unless %i[title author creator keywords subject].include?(k)
+            (@options[:metadata] ||= {})[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
+          @options[:select] = {range: [selection].flatten.compact.join(',')}
         end
 
         # Create or use a watermark image.
@@ -56,10 +55,12 @@ module Libis
         # The watermark options are (use symbols):
         #     - text: text to create a watermark from
         #     - file: watermark image to use
+        #     - image: same as above
         #     - 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.
+        #     - 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.
         #
@@ -69,16 +70,56 @@ module Libis
         # @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]
+          if options[:file] || options[:image]
+            watermark_image(options)
+          elsif options[:text]
+            watermark_text(options)
+          elsif options[:banner]
+            watermark_banner(options)
           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
+
+        def watermark_image(options = {})
+          options.key_strings_to_symbols!
+          @options[:watermark] = {command: 'image'}
+          @options[:watermark][:data] = options[:file] || options[:image]
+          @options[:watermark][:opacity] = options[:opacity] || '0.3'
+
+        end
+
+        def watermark_text(options = {})
+          options.key_strings_to_symbols!
+          @options[:watermark] = {command: 'text'}
+          @options[:watermark][:data] = (options[:text] || '© LIBIS').split('\n')
+          @options[:watermark][:rotation] = options[:rotation] if options[:rotation]
+          @options[:watermark][:size] = options[:size] if options[:size]
+          @options[:watermark][:gap] = options[:gap] if options[:gap].to_s =~ /^\s*\d+\s*$/
+          @options[:watermark][:padding] = options[:gap] if options[:gap].to_s =~ /^\s*(0+\.\d+|1\.0+)\s*$/
+          @options[:watermark][:padding] = options[:padding] if options[:padding]
+          @options[:watermark][:opacity] = options[:opacity] || '0.3'
+        end
+
+        # Create a vertical banner to the right side of each page
+        #
+        # The banner options are:
+        # - banner: text to put in the banner
+        # - add_filename: append filename to the text (use any value to enable)
+        # - fontsize: size of the font (in points)
+        # - width: width of the banner
+        # - (background|text)_color_(red|green|blue): color components of background and text
+        def watermark_banner(options = {})
+          options.key_strings_to_symbols!
+          @options[:watermark] = {command: 'banner'}
+          @options[:watermark][:data] = (options[:banner] || '© LIBIS')
+          @options[:watermark][:add_filename] = !!options[:add_filename]
+          @options[:watermark][:size] = options[:fontsize] if options[:fontsize]
+          @options[:watermark][:width] = options[:width] if options[:width]
+          @options[:watermark][:background_red] = options[:background_color_red] if options[:background_color_red]
+          @options[:watermark][:background_green] = options[:background_color_green] if options[:background_color_green]
+          @options[:watermark][:background_blue] = options[:background_color_blue] if options[:background_color_blue]
+          @options[:watermark][:text_red] = options[:text_color_red] if options[:text_color_red]
+          @options[:watermark][:text_green] = options[:text_color_green] if options[:text_color_green]
+          @options[:watermark][:text_blue] = options[:text_color_blue] if options[:text_color_blue]
         end
 
         # Optimize the PDF
@@ -88,7 +129,7 @@ module Libis
         #
         # - 0 : lowest quality (Acrobat Distiller 'Screen Optimized' equivalent)
         # - 1 : medium quality (Acrobat Distiller 'eBook' equivalent)
-        # - 2 : good quality
+        # - 2 : good quality (Acrobat Distiller 'Default' equivalent)
         # - 3 : high quality (Acrobat Distiller 'Print Optimized' equivalent)
         # - 4 : highest quality (Acrobat Distiller 'Prepress Optimized' equivalent)
         #
@@ -96,7 +137,7 @@ module Libis
         #
         # @param [Integer] setting quality setting. [0-4]
         def optimize(setting = 1)
-          @options['optimize'] = %w(screen ebook default printer prepress)[setting] if (0..4) === setting
+          @options[:optimize] = %w[screen ebook default printer prepress][setting] if (0..4).include?(setting)
         end
 
         def convert(source, target, format, opts = {})
@@ -104,84 +145,124 @@ module Libis
 
           result = nil
 
-          if (quality = @options.delete('optimize'))
-            result = optimize_pdf(source, target, quality)
-            return nil unless result
+          unless @options.empty?
+            result = convert_pdf(source, target)
             source = result
           end
 
-          unless @options.empty?
-            result = convert_pdf(source, target)
-            return nil unless result
+          if source && (quality = @options.delete(:optimize))
+            result = optimize_pdf(source, target, quality)
             source = result
           end
 
-          if format == :PDFA and source
+          if source && (format == :PDFA)
             result = pdf_to_pdfa(source, target)
           end
 
-          { 
+          {
             files: [result],
             converter: self.class.name
           }
-
         end
 
-        def optimize_pdf(source, target, quality)
+        protected
 
+        def optimize_pdf(source, target, quality)
           using_temp(target) do |tmpname|
             result = Libis::Format::Tool::PdfOptimizer.run(source, tmpname, quality)
-            unless result[:status] == 0
+            unless result[:err].empty?
               error("Pdf optimization encountered errors:\n%s", (result[:err] + result[:out]).join("\n"))
-              next nil
+              return nil
             end
             tmpname
           end
         end
 
         def convert_pdf(source, target)
+          result = source
+          result = add_watermark(result, target, @options[:watermark]) if @options[:watermark]
+          result = add_metadata(result, target, @options[:metadata]) if @options[:metadata]
+          result = select_range(result, target, @options[:select]) if @options[:select]
+          return result
+        end
+
+        def options_to_args(options)
+          options.map do |k, v|
+            key = "--#{k.to_s.tr_s('_', '-')}"
+            value = v
+            case value
+            when TrueClass
+              value = nil
+            when FalseClass
+              value = key = nil
+            when Array
+              value = value.map(&:to_s)
+            else
+              value = v.to_s
+            end
+            [key, value]
+          end.flatten.compact
+        end
+
+        def add_watermark(source, target, options)
+          command = options.delete(:command)
+          data = [options.delete(:data)].flatten.compact
+          args = data + options_to_args(options)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfTool.run(['watermark', command], source, tmpname, *args)
+            unless result[:err].empty?
+              error("Pdf watermarking encountered errors:\n%s", result[:err].join(join("\n")))
+              return nil
+            end
+            tmpname
+          end
+        end
+
+        def add_metadata(source, target, options)
+          args = options_to_args(options)
 
           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
-            )
+            result = Libis::Format::Tool::PdfTool.run('metadata', source, tmpname, *args)
             unless result[:err].empty?
-              error("Pdf conversion encountered errors:\n%s", result[:err].join(join("\n")))
-              next nil
+              error("Pdf metadata encountered errors:\n%s", result[:err].join(join("\n")))
+              return nil
             end
             tmpname
           end
+        end
+
+        def select_range(source, target, options)
+          args = options_to_args(options)
 
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfTool.run('select', source, tmpname, *args)
+            unless result[:err].empty?
+              error("Pdf select encountered errors:\n%s", result[:err].join(join("\n")))
+              return 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[:command][:status] != 0
-              error("Pdf/A conversion encountered errors:\n%s", (result[:command][:out] + result[:command][:err]).join("\n"))
-              next nil
+            unless result[:status].zero?
+              error("Pdf/A conversion encountered errors:\n%s", (result[:out] + result[:err]).join("\n"))
+              return nil
             else
               r = Libis::Format::Tool::PdfaValidator.run tmpname
               if r[:status] != 0
                 error "Pdf/A file failed to validate with following errors:\n%s", (r[:err] || r[:out] || []).join("\n")
-                next nil
+                return nil
               end
             end
             tmpname
           end
-
         end
-
       end
-
     end
   end
 end

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

@@ -1,6 +1,5 @@
-# coding: utf-8
+# frozen_string_literal: true
 
-require 'set'
 require 'singleton'
 
 require 'libis/tools/logger'
@@ -11,7 +10,6 @@ require_relative 'chain'
 module Libis
   module Format
     module Converter
-
       class Repository
         include Singleton
         include ::Libis::Tools::Logger
@@ -24,15 +22,15 @@ module Libis
           @converters_glob = File.join(File.dirname(__FILE__), '*_converter.rb')
         end
 
-        def Repository.register(converter_class)
+        def self.register(converter_class)
           instance.converters.add? converter_class
         end
 
-        def Repository.get_converters
+        def self.get_converters # rubocop:disable Naming/AccessorMethodName
           instance.get_converters
         end
 
-        def get_converters
+        def get_converters # rubocop:disable Naming/AccessorMethodName
           if converters.empty?
             Dir.glob(converters_glob).each do |filename|
               # noinspection RubyResolve
@@ -42,12 +40,12 @@ module Libis
           converters
         end
 
-        def Repository.get_converter_chain(src_type, tgt_type, operations = {})
+        def self.get_converter_chain(src_type, tgt_type, operations = {})
           instance.get_converter_chain src_type, tgt_type, operations
         end
 
         def get_converter_chain(src_type, tgt_type, operations = {})
-          msg = "conversion from #{src_type.to_s} to #{tgt_type.to_s}"
+          msg = "conversion from #{src_type} to #{tgt_type}"
           chain_list = find_chains src_type, tgt_type, operations
           # if chain_list.length > 1
           #   warn "Found more than one conversion chain for #{msg}. Picking the first one."
@@ -70,7 +68,6 @@ module Libis
         end
 
         def build_chains(chain)
-
           found = []
           chains = [chain]
 
@@ -81,18 +78,15 @@ module Libis
               new_chains += chains.map { |c| c.append(converter) }.flatten
             end
 
-            found = new_chains.select { |c| c.valid?}
+            found = new_chains.select(&:valid?)
             return found unless found.empty?
 
             chains = new_chains
           end
 
           found
-
         end
-
       end
-
     end
   end
 end

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

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require_relative 'base'
 
@@ -8,35 +8,31 @@ require 'libis/format/type_database'
 module Libis
   module Format
     module Converter
-
       class SpreadsheetConverter < Libis::Format::Converter::Base
-
         def self.input_types
-          [
-              :MSXLS,
-              :MSXLSX,
-              :OO_CALC
+          %i[
+            MSXLS
+            MSXLSX
+            OO_CALC
           ]
         end
 
         def self.output_types(format = nil)
           return [] unless input_types.include?(format)
+
           [:OO_CALC]
         end
 
         def spreadsheet_convert(_)
-          #force usage of this converter
+          # force usage of this converter
         end
 
         def convert(source, target, format, opts = {})
           super
 
           Format::Tool::SpreadsheetToOds.run(source, target)
-
         end
-
       end
-
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require 'libis/format/tool/ff_mpeg'
 
@@ -6,24 +8,19 @@ require 'fileutils'
 module Libis
   module Format
     module Converter
-
       class VideoConverter < Libis::Format::Converter::Base
-
         def self.input_types
-          [:WEBM, :MP4, :MPG, :MKV, :MJP2, :QTFF, :AVI, :OGGV, :WMV, :DV, :FLV, :SWF]
+          %i[WEBM MP4 MPG MKV MJP2 QTFF AVI OGGV WMV DV FLV SWF]
         end
 
         def self.output_types(format = nil)
           return [] unless input_types.include?(format)
-          [:GIF, :WEBM, :MP4, :MPG, :MKV, :MJP2, :QTFF, :AVI, :OGGV, :WMV, :DV, :FLV, :SWF]
-        end
 
-        def initialize
-          super
+          %i[GIF WEBM MP4 MPG MKV MJP2 QTFF AVI OGGV WMV DV FLV SWF]
         end
 
-        def quiet(v)
-          @flags[:quiet] = !!v
+        def quiet(value)
+          @flags[:quiet] = !!value
         end
 
         def format(format)
@@ -126,10 +123,10 @@ module Libis
 
         # @param [Boolean] value If set to true automatically selects optimal format for web viewing. Default: false
         def web_stream(value)
-          if value
-            @options[:video_codec] = 'h264'
-            @options[:audio_codec] = 'acc'
-          end
+          return unless value
+
+          @options[:video_codec] = 'h264'
+          @options[:audio_codec] = 'acc'
         end
 
         # @param [String] name name of a preset. See FFMpeg documentation for more info
@@ -170,7 +167,7 @@ module Libis
 
           elsif File.directory?(source)
 
-            sources = Dir[File.join(source, '**', '*')].reject {|p| File.directory? p}
+            sources = Dir[File.join(source, '**', '*')].reject { |p| File.directory? p }
             assemble_and_convert(sources, target)
 
           else
@@ -183,14 +180,13 @@ module Libis
             files: [target],
             converter: self.class.name
           }
-
         end
 
         def assemble_and_convert(sources, target)
-          Tempfile.create(%w(list .txt)) do |f|
-            sources.each {|src| f.puts src}
+          Tempfile.create(%w[list .txt]) do |f|
+            sources.each { |src| f.puts src }
             opts[:global] ||= []
-            opts[:global] += %w(-f concat)
+            opts[:global] += %w[-f concat]
             f.close
             target = convert_file(f.to_path, target)
           end
@@ -201,15 +197,15 @@ module Libis
 
         def convert_file(source, target)
           # FLV special: only supports aac and speex audio codecs
-          format = (@options[:format] || File.extname(target)[1..-1]).to_s.downcase
-          @options[:audio_codec] ||= 'aac' if %w'flv'.include?(format)
+          format = (@options[:format] || File.extname(target)[1..]).to_s.downcase
+          @options[:audio_codec] ||= 'aac' if %w[flv].include?(format)
 
           # SWF special: only supports mp3 audio codec
-          format = (@options[:format] || File.extname(target)[1..-1]).to_s.downcase
-          @options[:audio_codec] ||= 'mp3' if %w'swf'.include?(format)
+          format = (@options[:format] || File.extname(target)[1..]).to_s.downcase
+          @options[:audio_codec] ||= 'mp3' if %w[swf].include?(format)
 
           # Set up FFMpeg command line parameters
-          opts = {global: [], input: [], filter: [], output: []}
+          opts = { global: [], input: [], filter: [], output: [] }
           opts[:global] << '-hide_banner'
           opts[:global] << '-loglevel' << (@options[:quiet] ? 'fatal' : 'warning')
 
@@ -217,29 +213,21 @@ module Libis
           @options[:watermark_opacity] ||= 0.5
           if @options[:watermark_image]
             opts[:filter] << '-i' << @options[:watermark_image] << '-filter_complex'
-            opts[:filter] << "[1:v]format=argb,colorchannelmixer=aa=%f[wm];[0:v][wm]overlay=%s" %
-                [@options[:watermark_opacity], watermark_position_text]
+            opts[:filter] << Kernel.format('[1:v]format=argb,colorchannelmixer=aa=%f[wm];[0:v][wm]overlay=%s',
+                                           @options[:watermark_opacity], watermark_position_text)
           elsif @options[:watermark_text]
             @options[:watermark_text_size] ||= 10
             @options[:watermark_text_color] ||= 'white'
             @options[:watermark_text_shadow_color] ||= 'black'
             @options[:watermark_text_shadow_offset] ||= 1
-            filter_text = "drawtext=text='%s':%s:fontfile=%s:fontsize=%d:fontcolor=%s@%f" %
-                [
-                    @options[:watermark_text],
-                    watermark_position_text(true),
-                    Config[:watermark_font],
-                    @options[:watermark_text_size],
-                    @options[:watermark_text_color],
-                    @options[:watermark_opacity]
-                ]
-            filter_text += ':shadowcolor=%s@%f:shadowx=%d:shadowy=%d' %
-                [
-                    @options[:watermark_text_shadow_color],
-                    @options[:watermark_opacity],
-                    @options[:watermark_text_shadow_offset],
-                    @options[:watermark_text_shadow_offset]
-                ] if @options[:watermark_text_shadow_offset] > 0
+            filter_text = Kernel.format("drawtext=text='%s':%s:fontfile=%s:fontsize=%d:fontcolor=%s@%f",
+                                        @options[:watermark_text], watermark_position_text(true), Config[:watermark_font],
+                                        @options[:watermark_text_size], @options[:watermark_text_color], @options[:watermark_opacity])
+            if (@options[:watermark_text_shadow_offset]).positive?
+              filter_text += Kernel.format(':shadowcolor=%s@%f:shadowx=%d:shadowy=%d',
+                                           @options[:watermark_text_shadow_color], @options[:watermark_opacity],
+                                           @options[:watermark_text_shadow_offset], @options[:watermark_text_shadow_offset])
+            end
             opts[:filter] << '-vf' << filter_text
           end
           opts[:output] << '-ac' << @options[:audio_channels] if @options[:audio_channels]
@@ -251,7 +239,7 @@ module Libis
           opts[:output] << '-map_metadata:g' << '0:g' # Copy global metadata
           opts[:output] << '-map_metadata:s:a' << '0:s:a' # Copy audio metadata
           opts[:output] << '-map_metadata:s:v' << '0:s:v' # Copy video metadata
-          opts[:input] << '-accurate_seek' << (@options[:start].to_i < 0 ? '-sseof' : '-ss') << @options[:start] if @options[:start]
+          opts[:input] << '-accurate_seek' << (@options[:start].to_i.negative? ? '-sseof' : '-ss') << @options[:start] if @options[:start]
           opts[:input] << '-t' << @options[:duration] if @options[:duration]
           opts[:output] << '-qscale' << @options[:video_quality] if @options[:video_quality]
           opts[:output] << '-q:a' << @options[:audio_quality] if @options[:audio_quality]
@@ -277,21 +265,19 @@ module Libis
           w = for_text ? 'tw' : 'w'
           h = for_text ? 'th' : 'h'
           case @options[:watermark_position]
-            when 'bottom_left'
-              "x=#{margin}:y=H-#{h}-#{margin}"
-            when 'top_left'
-              "x=#{margin}:y=#{margin}"
-            when 'bottom_right'
-              "x=W-#{w}-#{margin}:y=H-#{h}-#{margin}"
-            when 'top_right'
-              "x=W-#{w}-#{margin}:y=#{margin}"
-            else
-              "x=#{margin}:y=H-#{h}-#{margin}"
+          when 'bottom_left'
+            "x=#{margin}:y=H-#{h}-#{margin}"
+          when 'top_left'
+            "x=#{margin}:y=#{margin}"
+          when 'bottom_right'
+            "x=W-#{w}-#{margin}:y=H-#{h}-#{margin}"
+          when 'top_right'
+            "x=W-#{w}-#{margin}:y=#{margin}"
+          else
+            "x=#{margin}:y=H-#{h}-#{margin}"
           end
         end
-
       end
-
     end
   end
-end
+end