libis-format 1.3.2 → 2.0.0

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require_relative 'base'
+
+require 'libis/format/tool/pdf_split'
+
+module Libis
+  module Format
+    module Converter
+
+      # noinspection DuplicatedCode
+      class PdfSplitter < 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_split(_)
+          #force usage of this converter
+        end
+
+        def self.category
+          :splitter
+        end
+
+        # Split at given page. If omitted or nil, the source PDF will be split at every page
+        def page(v)
+          @page = v unless v.blank
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          result = split(source, target)
+          return nil unless result
+
+          result
+        end
+
+        private
+
+        def split(source, target)
+
+          options = @page ? ['--page', @page] : ['--every_page']
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfSplit.run(source, tmpname, *options)
+            unless result[:err].empty?
+              error("Pdf split 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_watermarker.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+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'
+
+module Libis
+  module Format
+    module Converter
+
+      class PdfWatermarker < 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_watermark(_)
+          #force usage of this converter
+        end
+
+        def initialize
+          super
+          @options[:text] = '© LIBIS'
+          @options[:opacity] = '0.3'
+        end
+
+        def file(v)
+          @options[:file] = v.blank? ? nil : v
+        end
+
+        def text(v)
+          @options[:text] = v
+        end
+
+        def rotation(v)
+          @options[:rotation] = v unless v.blank?
+        end
+
+        def size(v)
+          @options[:size] = v unless v.blank?
+        end
+
+        def opacity(v)
+          @options[:opacity] = v unless v.blank?
+        end
+
+        def gap_size(v)
+          @options[:gap_size] = v
+        end
+
+        def gap_ratio(v)
+          @options[:gap_ratio] = v
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          result = convert_pdf(source, target)
+          return nil unless result
+
+          result
+
+        end
+
+        OPTIONS_TABLE = {
+            file: 'wm_image',
+            text: 'wm_text',
+            rotation: 'wm_text_rotation',
+            size: 'wm_font_size',
+            opacity: 'wm_opacity',
+            gap_size: 'wm_gap_size',
+            gap_ratio: 'wm_gap_ratio'
+        }
+        # noinspection DuplicatedCode
+        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
+                    v = v.split('\n') unless v.blank? if k == :text
+                    k = OPTIONS_TABLE[k] || k
+                    ["--#{k}", (v.is_a?(Array) ? v : v.to_s)]
+                  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/repository.rb

@@ -1,5 +1,6 @@
-# frozen_string_literal: true
+# coding: utf-8
 
+require 'set'
 require 'singleton'
 
 require 'libis/tools/logger'
@@ -10,6 +11,7 @@ require_relative 'chain'
 module Libis
   module Format
     module Converter
+
       class Repository
         include Singleton
         include ::Libis::Tools::Logger
@@ -22,15 +24,15 @@ module Libis
           @converters_glob = File.join(File.dirname(__FILE__), '*_converter.rb')
         end
 
-        def self.register(converter_class)
+        def Repository.register(converter_class)
           instance.converters.add? converter_class
         end
 
-        def self.get_converters # rubocop:disable Naming/AccessorMethodName
+        def Repository.get_converters
           instance.get_converters
         end
 
-        def get_converters # rubocop:disable Naming/AccessorMethodName
+        def get_converters
           if converters.empty?
             Dir.glob(converters_glob).each do |filename|
               # noinspection RubyResolve
@@ -40,12 +42,12 @@ module Libis
           converters
         end
 
-        def self.get_converter_chain(src_type, tgt_type, operations = {})
+        def Repository.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 #{tgt_type}"
+          msg = "conversion from #{src_type.to_s} to #{tgt_type.to_s}"
           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."
@@ -68,6 +70,7 @@ module Libis
         end
 
         def build_chains(chain)
+
           found = []
           chains = [chain]
 
@@ -78,15 +81,18 @@ module Libis
               new_chains += chains.map { |c| c.append(converter) }.flatten
             end
 
-            found = new_chains.select(&:valid?)
+            found = new_chains.select { |c| c.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,38 +1,44 @@
-# frozen_string_literal: true
+# encoding: utf-8
 
 require_relative 'base'
 
 require 'libis/format/tool/spreadsheet_to_ods'
-require 'libis/format/type_database'
+require 'libis/format/library'
 
 module Libis
   module Format
     module Converter
+
       class SpreadsheetConverter < Libis::Format::Converter::Base
+
         def self.input_types
-          %i[
-            MSXLS
-            MSXLSX
-            OO_CALC
+          [
+              :MSXLS,
+              :MSXLSX,
+              :OO_CALC
           ]
         end
 
         def self.output_types(format = nil)
-          return [] unless input_types.include?(format)
-
+          return [] unless input_types.include?(format) if 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)
+          return nil unless Format::Tool::SpreadsheetToOds.run(source, target)
+
+          target
+
         end
+
       end
+
     end
   end
 end

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

@@ -1,26 +1,29 @@
-# frozen_string_literal: true
-
 require_relative 'base'
-require 'libis/format/tool/ff_mpeg'
+require 'libis/format/tool/ffmpeg'
 
 require 'fileutils'
 
 module Libis
   module Format
     module Converter
+
       class VideoConverter < Libis::Format::Converter::Base
+
         def self.input_types
-          %i[WEBM MP4 MPG MKV MJP2 QTFF AVI OGGV WMV DV FLV SWF]
+          [: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)
+          return [] unless input_types.include?(format) if format
+          [:GIF, :WEBM, :MP4, :MPG, :MKV, :MJP2, :QTFF, :AVI, :OGGV, :WMV, :DV, :FLV, :SWF]
+        end
 
-          %i[GIF WEBM MP4 MPG MKV MJP2 QTFF AVI OGGV WMV DV FLV SWF]
+        def initialize
+          super
         end
 
-        def quiet(value)
-          @flags[:quiet] = !!value
+        def quiet(v)
+          @flags[:quiet] = !!v
         end
 
         def format(format)
@@ -123,10 +126,10 @@ module Libis
 
         # @param [Boolean] value If set to true automatically selects optimal format for web viewing. Default: false
         def web_stream(value)
-          return unless value
-
-          @options[:video_codec] = 'h264'
-          @options[:audio_codec] = 'acc'
+          if value
+            @options[:video_codec] = 'h264'
+            @options[:audio_codec] = 'acc'
+          end
         end
 
         # @param [String] name name of a preset. See FFMpeg documentation for more info
@@ -167,7 +170,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
@@ -176,17 +179,15 @@ module Libis
 
           end
 
-          {
-            files: [target],
-            converter: self.class.name
-          }
+          target
+
         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
@@ -197,15 +198,15 @@ module Libis
 
         def convert_file(source, target)
           # FLV special: only supports aac and speex audio codecs
-          format = (@options[:format] || File.extname(target)[1..]).to_s.downcase
-          @options[:audio_codec] ||= 'aac' if %w[flv].include?(format)
+          format = (@options[:format] || File.extname(target)[1..-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..]).to_s.downcase
-          @options[:audio_codec] ||= 'mp3' if %w[swf].include?(format)
+          format = (@options[:format] || File.extname(target)[1..-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')
 
@@ -213,21 +214,29 @@ module Libis
           @options[:watermark_opacity] ||= 0.5
           if @options[:watermark_image]
             opts[:filter] << '-i' << @options[:watermark_image] << '-filter_complex'
-            opts[:filter] << Kernel.format('[1:v]format=argb,colorchannelmixer=aa=%f[wm];[0:v][wm]overlay=%s',
-                                           @options[:watermark_opacity], watermark_position_text)
+            opts[:filter] << "[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 = 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
+            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
             opts[:filter] << '-vf' << filter_text
           end
           opts[:output] << '-ac' << @options[:audio_channels] if @options[:audio_channels]
@@ -239,7 +248,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.negative? ? '-sseof' : '-ss') << @options[:start] if @options[:start]
+          opts[:input] << '-accurate_seek' << (@options[:start].to_i < 0 ? '-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]
@@ -265,19 +274,21 @@ 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

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

@@ -1,19 +1,18 @@
-# frozen_string_literal: true
-
 require_relative 'base'
 
 module Libis
   module Format
     module Converter
+
       class XsltConverter < Libis::Format::Converter::Base
+
         def self.input_types
           [:XML]
         end
 
         def self.output_types(format = nil)
-          return [] if format && !input_types.include?(format)
-
-          %i[XML HTML TXT]
+          return [] unless input_types.include?(format) if format
+          [:XML, :HTML, :TXT]
         end
 
         def xsl_file(file_path)
@@ -35,12 +34,12 @@ module Libis
 
           FileUtils.mkpath(File.dirname(target))
 
-          if RUBY_PLATFORM == 'java'
+          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.write(target, result.to_s)
+            File.open(target, 'w') {|f| f.write(result.to_s)}
           else
             require 'nokogiri'
 
@@ -87,17 +86,16 @@ module Libis
               error "Error transforming '#{source}' with '#{file}': #{e.message} @ #{e.backtrace[0]}"
               return nil
             ensure
-              fp.close unless fp.nil? || fp.closed?
+              fp.close unless fp.nil? or fp.closed?
             end
 
-            {
-              command: { status: 0 },
-              files: [target]
-            }
-
+            target
           end
+
         end
+
       end
+
     end
   end
 end

data/lib/libis/format/converter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: true
+# code utf-8
 
 module Libis
   module Format