libis-format 1.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21f527308cef3b9865c24c956f5a76cf67973400
-  data.tar.gz: 19c867aef5d28da24a3354025b11fc718b885a7f
+  metadata.gz: a96a71d90952cf5d8be62d9b82ac6fc22c4f080a
+  data.tar.gz: 79bda271ae8b628e96c7a3d19b65884a3fe1eee0
 SHA512:
-  metadata.gz: 3af22a3b301bc89a0839215a96a571d729478c61f3d414ee144e7f011d16443f4e604efd8f6afb0b40d2dd02dc77ca65878dfba7b29a6f4bc186beec8373b437
-  data.tar.gz: 81bebc7836625f251e9365100bfdb4a13d3ec4424a26a536521bb1776a11d96472645af1e360077ff64d5ef4e6f08671e0c87330d8fa32f5230b390509a016ce
+  metadata.gz: 303f4353c79d988110668ddc1c4bb5867d4e644b30d1a6f60e24da13a2f8f99703ab1b8f5afba73ed11aee0cfdd8bad6e759e857350a97d734d021fcfca31c32
+  data.tar.gz: 612a76df7a9907900aa292e68065f3c13d1362edffa01cbf2425edb8c8f41040d17871680ad7bab430a49790da96bba323ce2706ab13dfa39494ca8795e7d639

data/bin/libis_format

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'libis/format/command_line'
+
+Libis::Format::CommandLine.start(ARGV)

data/lib/libis/format.rb

@@ -4,6 +4,7 @@ module Libis
   module Format
     autoload :Config, 'libis/format/config'
     autoload :TypeDatabase, 'libis/format/type_database'
+    autoload :TypeDatabaseImpl, 'libis/format/type_database_impl'
     autoload :Identifier, 'libis/format/identifier'
 
     autoload :Tool, 'libis/format/tool'

data/lib/libis/format/cli/convert.rb

@@ -0,0 +1,310 @@
+require 'awesome_print'
+require 'libis-format'
+require 'libis-tools'
+require 'libis/tools/extend/hash'
+require 'fileutils'
+require 'tmpdir'
+require 'yaml'
+
+require 'libis/format/converter/image_converter'
+
+require_relative 'sub_command'
+
+module Libis
+  module Format
+    module Cli
+      class Convert < SubCommand
+
+        no_commands do
+          def self.description(field)
+            "#{STRING_CONFIG[field]}." + (DEFAULT_CONFIG[field].nil? ? '' : " default: #{DEFAULT_CONFIG[field]}")
+          end
+        end
+
+        DEFAULT_CONFIG = {
+            scale: '100%',
+            resize: '100%',
+            wm_tiles: 4,
+            wm_resize: 1.0,
+            wm_gap: 0.2,
+            wm_rotation: 30,
+            wm_opacity: 0.1,
+            wm_gravity: 'center',
+            wm_composition: 'modulate'
+        }
+
+        STRING_CONFIG = {
+            page: 'Page number to select for multipage documents',
+            quiet: 'suppress all warning messages. Error messages are still reported',
+            scale: 'minify / magnify the image with pixel block averaging and pixel replication, respectively',
+            resize: 'Resize the image',
+            resample: 'Resize the image so that its rendered size remains the same as the original at the specified target resolution',
+            flatten: 'Create a canvas the size of the first images virtual canvas using the current -background color, and -compose each image in turn onto that canvas. Images falling outside that canvas is clipped',
+            delete_date: 'Remove modified date and created date metadata from the target image',
+            colorspace: 'Set the image colorspace',
+            profile: 'Specify color profile used for the image',
+            wm_text: 'Create watermark with given text',
+            wm_file: 'Create watermark from given file',
+            wm_tiles: 'Number of tiles of the watermark to distribute over the image. 0: no tiling, 1: watermark image scaled to fit image, n>1: at least n tiles horizontally/vertically, n<0: tile without recaling',
+            wm_resize: 'Resize the watermark image (fraction 0.0 - 1.0)',
+            wm_gap: 'Leave n % of whitespace between the watermark images. Similar effect can be achieved with wm_resize',
+            wm_rotation: 'Rotate the watermark text n degrees counterclockwise (0-360)',
+            wm_opacity: 'Opacity of the watermark (fraction 0.0 - 1.0)',
+            wm_gravity: 'Center point of the watermark overlay',
+            wm_composition: 'Set the type of image composition'
+        }
+
+        desc 'auto SOURCE TARGET [options]', 'Convert SOURCE file to TARGET file using auto algorithm'
+        long_desc <<-DESC
+  
+        'auto SOURCE TARGET [options]' will convert a file according to the best conversion chain algorithm.
+
+        A source file name and target file name should be supplied. The source file should exist and be readable.
+        The target file should be writable, but should not exist.
+
+        Optionally an options file name can be added to the command line. The options file should be a valid YAML
+        file that contains either a Hash or an Array of Hashes. The content should contain the required methods and 
+        arguments that any of the targetted converters support.
+
+        The source file's format will be identified by the Libis::Format::Identifier and the target file's format
+        will be derived from the file's extension. The Libis::Format::TypeDatabase is used to relate extensions
+        with formats.
+
+        DESC
+
+        method_option :options, aliases: '-o', desc: 'Options file'
+
+        def auto(source_file, target_file)
+          options_file = options[:options]
+          opts = check_input(source_file, target_file, options_file)
+          output, converter = do_convert(source_file, target_file, opts)
+          prompt.ok "Output file '#{output}' created with converter #{converter}."
+        end
+
+        desc 'image SOURCE TARGET [options]', 'Convert SOURCE image to TARGET image using ImageConverter'
+        long_desc <<-DESC
+
+            'image SOURCE TARGET [options]' will convert a SOURCE image to TARGET image using the ImageConverter.
+
+            A source file name and target file name should be supplied. The source file should exist and be readable.
+            The target file should be writable, but should not exist.
+
+            The target file's format will be derived from the file's extension. The Libis::Format::TypeDatabase is used 
+            to relate extensions with formats.
+
+        DESC
+
+        method_option :page, type: :numeric, aliases: '-p', desc: description(:page)
+        method_option :quiet, type: :boolean, aliases: '-q', desc: description(:quiet)
+        method_option :scale, type: :numeric, aliases: '-c', desc: description(:scale)
+        method_option :resize, type: :numeric, aliases: '-r', desc: description(:resize)
+        method_option :resample, type: :numeric, aliases: '-m', desc: description(:resample)
+        method_option :flatten, type: :boolean, aliases: '-f', desc: description(:flatten)
+        method_option :delete_date, type: :boolean, aliases: '-dd', desc: description(:delete_date)
+        method_option :colorspace, aliases: '-cs', desc: description(:colorspace)
+        method_option :profile, aliases: '-prof', desc: description(:profile)
+        method_option :wm_text, desc: description(:wm_text)
+        method_option :wm_file, desc: description(:wm_file)
+        method_option :wm_tiles, type: :numeric, desc: description(:wm_tiles)
+        method_option :wm_resize, type: :numeric, desc: description(:wm_resize)
+        method_option :wm_gap, type: :numeric, desc: description(:wm_gap)
+        method_option :wm_rotation, type: :numeric, desc: description(:wm_rotation)
+        method_option :wm_opacity, type: :numeric, desc: description(:wm_opacity)
+        method_option :wm_gravity, desc: description(:wm_gravity)
+        method_option :wm_composition, desc: description(:wm_composition)
+
+        def image(source_file, target_file)
+          check_input(source_file, target_file)
+          convert_image(source_file, target_file)
+          prompt.ok "Output file '#{target_file}' created with image converter."
+        end
+
+        protected
+
+        def do_convert(source_file, target_file, opts)
+          format_info = format_identifier(source_file)
+          src_mime = format_info[:mimetype]
+          source_format = format_info[:TYPE]
+          unless source_format
+            prompt.error "File item %s format (#{src_mime}) is not supported."
+            exit
+          end
+          target_format = get_format(target_file)
+          converterlist = []
+          temp_files = []
+          opts.each do |o|
+            o = o.dup
+            tgt_format = o.delete(:target_format) || target_format
+            tgt_file = tempname(source_file, tgt_format)
+            temp_files << tgt_file
+            begin
+              source_file, converter = convert_file(source_file, tgt_file, source_format, tgt_format, o)
+            rescue Exception => e
+              prompt.error "File conversion of '%s' from '%s' to '%s' failed: %s @ %s" %
+                               [source_file, source_format, tgt_format, e.message, e.backtrace.first]
+              exit
+            end
+            source_format = tgt_format
+            converterlist << converter
+          end
+          converter = converterlist.join(' + ')
+          if target_file
+            FileUtils.mkpath(File.dirname(target_file))
+            FileUtils.copy(source_file, target_file)
+          else
+            target_file = temp_files.pop
+          end
+          temp_files.each {|tmp_file| FileUtils.rm_f tmp_file}
+          [target_file, converter]
+        end
+
+        def convert_file(src_file, tgt_file, src_format, tgt_format, opts)
+          converter = Libis::Format::Converter::Repository.get_converter_chain(src_format, tgt_format, opts)
+
+          unless converter
+            prompt.error "Could not find converter for #{src_format} -> #{tgt_format} with #{opts}"
+            exit
+          end
+
+          converter_name = converter.to_s
+          prompt.say 'Converting file %s to %s with %s ' % [src_file, tgt_file, converter_name]
+          converted = converter.convert(src_file, tgt_file)
+
+          unless converted && converted == tgt_file
+            prompt.error 'File conversion failed (%s).', converter_name
+            return [nil, converter_name]
+          end
+
+          [tgt_file, converter_name]
+        end
+
+        def convert_image(source_file, target_file)
+          target_format = get_format(target_file)
+          converter = Libis::Format::Converter::ImageConverter.new
+          converter.page options[:page] if options[:page]
+          converter.quiet options[:quiet] if options[:quiet]
+          converter.scale options[:scale] if options[:scale]
+          converter.resize options[:resize] if options[:resize]
+          converter.resample options[:resample] if options[:resample]
+          converter.flatten if options[:flatten]
+          converter.delete_date if options[:delete_date]
+          converter.colorspace options[:colorspace] if options[:colorspace]
+          converter.profile options[:profile] if options[:profile]
+          if options[:wm_text] || options[:wm_file]
+            wm_options = {}
+            wm_options[:text] = options[:wm_text] if options[:wm_text]
+            wm_options[:file] = options[:wm_file] if options[:wm_file]
+            wm_options[:tiles] = options[:wm_tiles] if options[:wm_tiles]
+            wm_options[:resize] = options[:wm_resize] if options[:wm_resize]
+            wm_options[:gap] = options[:wm_gap] if options[:wm_gap]
+            wm_options[:rotation] = options[:wm_rotation] if options[:wm_rotation]
+            wm_options[:opacity] = options[:wm_opacity] if options[:wm_opacity]
+            wm_options[:gravity] = options[:wm_gravity] if options[:wm_gravity]
+            wm_options[:composition] = options[:wm_composition] if options[:wm_composition]
+            converter.watermark(wm_options)
+          end
+          converter.convert source_file, target_file, target_format
+        end
+
+        private
+
+        def check_input(source_file, target_file, options_file = nil)
+          # Check if source file exists and can be read
+          unless source_file && File.exist?(source_file) && File.readable?(source_file)
+            prompt.error "Fatal error trying to access source file '#{source_file}'."
+            exit
+          end
+          # Check if target file argument is supplied
+          unless target_file
+            prompt.error "Fatal error: no target file name supplied."
+            exit
+          end
+          # Check if target file directory can be created
+          begin
+            FileUtils.mkdir_p(File.dirname(target_file))
+          rescue SystemCallError => e
+            prompt.error "Fatal error trying to create folder for target file: #{e.message}"
+            exit
+          end
+
+          return [{}] unless options_file
+
+          # Check if options file exists and can be read
+          unless File.exist?(options_file) && File.readable?(options_file)
+            prompt.error "Fatal error trying to access options file '#{options_file}'."
+            exit
+          end
+
+          begin
+            opts = ::YAML.load_file(options_file)
+            opts = case opts
+                   when Hash
+                     [opts]
+                   when Array
+                     opts
+                   when NilClass
+                     [{}]
+                   else
+                     prompt.error "Options file contents should be a Hash or an Array of Hashes."
+                     exit
+                   end
+            opts.each {|h| h.key_strings_to_symbols!(recursive: true)}
+            opts
+          rescue Exception => e
+            prompt.error "Fatal error trying to parse options file: #{e.message}"
+            exit
+          end
+
+        end
+
+        def tempname(source_file, target_format)
+          # noinspection RubyResolve
+          Dir::Tmpname.create(
+              [File.basename(source_file, '.*'), ".#{extname(target_format)}"]
+          ) {}
+        end
+
+        def extname(format)
+          Libis::Format::TypeDatabase.type_extentions(format).first
+        end
+
+        def get_format(file_name)
+          Libis::Format::TypeDatabase.ext_types(File.extname(file_name)).first
+        end
+
+        def format_identifier(file)
+          prompt.say "Identifying format of file '#{file}'"
+          result = Libis::Format::Identifier.get(file) || {}
+          process_messages(result)
+          format = result[:formats][file]
+          unless format[:mimetype]
+            prompt.warn "Could not determine MIME type. Using default 'application/octet-stream'."
+            result[:puid] ||= 'fmt/unknown'
+          end
+          prompt.say "#{file} format: #{format[:GROUP]}, #{format[:TYPE]} (puid: #{format[:puid]}) mimetype: #{format[:mimetype]}"
+          format
+        end
+
+        def process_messages(format_result)
+          format_result[:messages].each do |msg|
+            case msg[0]
+            when :debug
+              prompt.say msg[1]
+            when :info
+              prompt.say msg[1]
+            when :warn
+              prompt.warn msg[1]
+            when :error
+              prompt.error msg[1]
+            when :fatal
+              prompt.error msg[1]
+            else
+              prompt.say "#{msg[0]}: #{msg[1]}"
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/format/cli/format.rb

@@ -0,0 +1,77 @@
+require 'awesome_print'
+require 'libis-format'
+require 'libis-tools'
+
+require_relative 'sub_command'
+
+module Libis
+  module Format
+    module Cli
+      class Format < SubCommand
+
+        no_commands do
+          def self.description(field)
+            "#{STRING_CONFIG[field]}." + (DEFAULT_CONFIG[field].nil? ? '' : " default: #{DEFAULT_CONFIG[field]}")
+          end
+        end
+
+        DEFAULT_CONFIG = {
+            droid: true,
+            fido: true,
+            file: true,
+            xml_validation: true
+        }
+
+        STRING_CONFIG = {
+            droid: 'Use Droid to identify the format',
+            fido: 'Use Fido to identify the format',
+            file: 'Use File to identify the format',
+            xml_validation: 'When XML file found, validate the file against known XML schemas',
+        }
+
+        desc 'identify FILE [options]', 'Identify the FILE using a combination of the tools.'
+        long_desc <<-DESC
+  
+        'identify FILE [options]' will idnetify a file using a combination of tools.
+
+        The file will be identified by each of the selected tools in turn and the format with best score will be
+        selected to give the final result. The score is determined by the identification method and will be lowered if
+        a known weak format (e.g. zip file) is detected.
+
+        The tool will display as much information about the format as possible, including the format candidates that
+        were not selected.
+
+        DESC
+
+        method_option :droid, default: DEFAULT_CONFIG[:droid], type: :boolean, desc: STRING_CONFIG[:droid]
+        method_option :fido, default: DEFAULT_CONFIG[:fido], type: :boolean, desc: STRING_CONFIG[:fido]
+        method_option :file, default: DEFAULT_CONFIG[:file], type: :boolean, desc: STRING_CONFIG[:file]
+        method_option :xml_validation, default: DEFAULT_CONFIG[:xml_validation], type: :boolean, desc: STRING_CONFIG[:xml_validation]
+
+        def identify(source_file)
+          ::Libis::Tools::Config.logger.level = :WARN
+          opts = options.inject({}) { |h, x| h[x.first.to_sym] = x.last; h}
+          opts[:keep_output] = true
+          result = ::Libis::Format::Identifier.get source_file, opts
+          puts '--- messages ---'
+          result[:messages].each do |message|
+            puts "#{message[0]} : #{message[1]}"
+          end
+
+          puts '--- formats ---'
+          result[:formats].each do |file, info|
+            puts "#{file}:"
+            ap info
+          end
+
+          puts '--- tool results ---'
+          result[:output].each do |file, info|
+            puts "#{file}:"
+            ap info
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/format/cli/prompt_helper.rb

@@ -0,0 +1,87 @@
+require 'tty-prompt'
+require 'pastel'
+
+module Libis
+  module Format
+    module Cli
+      module PromptHelper
+
+        attr_reader :prompt, :pastel
+
+        def initialize(*args)
+          @prompt = TTY::Prompt.new
+          @pastel = Pastel.new
+          super
+        end
+
+        protected
+
+        private
+
+        def index_of(list, value)
+          i = list.index(value)
+          i += 1 if i
+          i || 1
+        end
+
+        def ask(question, bool: false, enum: nil, default: nil, mask: false)
+          cmd, args, opts = :ask, [question], {}
+          if enum
+            cmd = :select
+            args << enum
+            # Change default to its index in the enum
+            default = index_of(enum, default)
+          end
+          cmd = :mask if mask
+          opts[:default] = default if default
+          cmd = (opts[:default] ? :yes? : :no?) if bool
+          prompt.send(cmd, *args, opts)
+        end
+
+        def tree_select(path, question: nil, file: false, page_size: 22, filter: true, cycle: false, create: false,
+                        default_choices: nil)
+          path = Pathname.new(path) unless path.is_a? Pathname
+
+          return path unless path.exist?
+          path = path.realpath
+
+          dirs = path.children.select(&:directory?).sort
+          files = file ? path.children.select(&:file?).sort : []
+
+          choices = []
+          choices << {name: "Folder: #{path}", value: path, disabled: file ? '' : false}
+          choices += default_choices if default_choices
+          choices << {name: '-- new directory --', value: -> do
+            new_name = prompt.ask('new directory name:', modify: :trim, required: true)
+            new_path = path + new_name
+            FileUtils.mkdir(new_path.to_path)
+            new_path
+          end
+          } if create
+
+          choices << {name: "-- new file --", value: -> do
+            new_name = prompt.ask('new file name:', modify: :trim, required: true)
+            path + new_name
+          end
+          } if file && create
+
+          choices << {name: '[..]', value: path.parent}
+
+          dirs.each {|d| choices << {name: "[#{d.basename}]", value: d}}
+          files.each {|f| choices << {name: f.basename.to_path, value: f}}
+
+          question ||= "Select #{'file or ' if files}directory"
+          selection = prompt.select question, choices,
+                                    per_page: page_size, filter: filter, cycle: cycle, default: file ? 2 : 1
+
+          return selection unless selection.is_a? Pathname
+          return selection.to_path if selection == path || selection.file?
+
+          tree_select selection, question: question, file: file, page_size: page_size, filter: filter,
+                      cycle: cycle, create: create, default_choices: default_choices
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/format/cli/sub_command.rb

@@ -0,0 +1,22 @@
+require 'thor'
+require_relative 'prompt_helper'
+
+module Libis
+  module Format
+    module Cli
+      class SubCommand < Thor
+
+        include PromptHelper
+
+        def self.banner(command, namespace = nil, subcommand = false)
+          "#{basename} #{subcommand_prefix} #{command.usage}"
+        end
+
+        def self.subcommand_prefix
+          self.name.gsub(%r{.*::}, '').gsub(%r{^[A-Z]}) { |match| match[0].downcase }.gsub(%r{[A-Z]}) { |match| "-#{match[0].downcase}" }
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/format/command_line.rb

@@ -0,0 +1,25 @@
+require 'thor'
+require 'tty-prompt'
+require 'tty-config'
+
+require 'libis/format/cli/convert'
+require 'libis/format/cli/format'
+
+module Libis
+  module Format
+
+    class CommandLine < Thor
+
+      def self.exit_on_failure?
+        true
+      end
+
+      desc 'convert', 'perform format conversion on a given file'
+      subcommand 'convert', Cli::Convert
+
+      desc 'format', 'perform format identification on a given file or directory'
+      subcommand 'format', Cli::Format
+    end
+
+  end
+end

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

@@ -6,18 +6,20 @@ require 'libis/format/identifier'
 require 'mini_magick'
 require 'fileutils'
 
-MiniMagick.logger.level = ::Logger::ERROR
+MiniMagick.logger.level = ::Logger::UNKNOWN
 
 MiniMagick.configure do |config|
   # config.cli = :graphicsmagick
   config.validate_on_create = false
   config.validate_on_write = false
+  config.whiny = false
 end
 
 module Libis
   module Format
     module Converter
 
+      # noinspection RubyTooManyInstanceVariablesInspection
       class ImageConverter < Libis::Format::Converter::Base
 
         def self.input_types
@@ -43,7 +45,7 @@ module Libis
         end
 
         def quiet(v)
-          @flags[:quiet] = !!v
+          @quiet = !!v
         end
 
         def page(nr)
@@ -70,16 +72,16 @@ module Libis
           @options[:resample] = value
         end
 
-        def flatten
-          @flags[:flatten] = true
+        def flatten(value = true)
+          @options[:flatten] = !!value
         end
 
         def colorspace(value)
           @options[:colorspace] = value
         end
 
-        def delete_date
-          @delete_date = true
+        def delete_date(value = true)
+          @delete_date = !!value
         end
 
         def profile(icc)
@@ -92,9 +94,16 @@ module Libis
         #     - file: watermark image to use
         #     - text: text to create a watermark from
         #     - rotation: rotation of the watermark text (counter clockwise in degrees; integer number) - default 30
-        #     - size: size of the watermark (integer > 0, 1/n of image size) - default 4
-        #     - opacity: opacity of the watermark (fraction 0.0 - 1.0) - default 0.3
+        #     - tiles: number of tiles of the watermark - default 4
+        #       - 0: no tiling, so only 1 watermark will be placed with the original size
+        #       - 1: 1 tile, so the watermark will be scaled up to fill the image
+        #       - n > 1: minimum n tiles in both directions
+        #       - n < 0: tile without scaling the watermark
+        #     - size: same as tiles - for backwards compatibility
+        #     - resize: fraction 0.0 - 1.0
         #     - gap: size of the gap between watermark instances. Fractions as percentage of widht/height. - default 0.2
+        #     - opacity: opacity of the watermark (fraction 0.0 - 1.0) - default 0.1
+        #     - gravity: center point of the overlay - default 'center'
         # 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.
         #
@@ -104,14 +113,17 @@ module Libis
         # @param [Hash] options Hash of options for watermark creation.
         def watermark(options = {})
           text = options[:text] || '© LIBIS'
-          @wm_size = (options[:size] || '4').to_i
+          @wm_tiles = (options[:tiles] || '4').to_i
+          @wm_tiles ||= (options[:size] || '4').to_i
+          @wm_resize = ((options[:resize]).to_f * 100).to_i if options[:resize]
           @wm_opacity = ((options[:opacity] || 0.1).to_f * 100).to_i
           @wm_composition = options[:composition] || 'modulate'
-          gap = ((options[:gap] || 0.2).to_f * 100).to_i
+          @wm_gravity = options[:gravity] || 'center'
+          @wm_gap = ((options[:gap] || 0.2).to_f * 100).to_i
           rotation = 360 - (options[:rotation] || 30).to_i
           @wm_image = MiniMagick::Image.new(options[:file]) if options[:file]
           unless @wm_image && @wm_image.valid?
-            image = options[:file] || (Dir::Tmpname.create(%w(wm_image .png)) { |_|})
+            image = options[:file] || (Dir::Tmpname.create(%w(wm_image .png)) {|_|})
             # noinspection RubyResolve
             MiniMagick::Tool::Convert.new do |convert|
               # noinspection RubyLiteralArrayInspection
@@ -123,7 +135,6 @@ module Libis
               convert << "label:#{text}"
               convert.rotate rotation
               convert.trim.repage.+
-              convert.bordercolor('transparent').border("#{gap}%")
               convert << image
             end
             if options[:file]
@@ -150,19 +161,20 @@ module Libis
             assemble_and_convert(source, target, format)
 
           elsif File.directory?(source)
-            source_list = Dir[File.join(source, '**', '*')].reject { |p| File.directory? p }
+            source_list = Dir[File.join(source, '**', '*')].reject {|p| File.directory? p}
 
             assemble_and_convert(source_list, target, format)
 
           else
 
-            image = MiniMagick::Image.new(source)
+            image = MiniMagick::Image.new(source) { |b| b.quiet }
 
             if image.pages.size > 1
               if @page
                 convert_image(image.pages[@page].path, target, format)
               else
-                assemble_and_convert(image.pages.map { |page| page.path }, target, format)
+                # noinspection RubyBlockToMethodReference
+                assemble_and_convert(image.pages.map {|page| page.path}, target, format)
               end
             else
               convert_image(source, target, format)
@@ -177,13 +189,14 @@ module Libis
 
           warn 'Received multiple images as input and single page format as target.' unless self.class.multipage?(format)
           converted_pages = sources.inject([]) do |list, path|
+            # noinspection RubyArgCount
             converted = Tempfile.new(['page-', ".#{Libis::Format::TypeDatabase.type_extentions(format).first}"])
             convert_image(path, converted.path, format)
             list << converted
           end
           MiniMagick::Tool::Convert.new do |b|
             b.append unless self.class.multipage?(format)
-            converted_pages.each { |page| b << page.path }
+            converted_pages.each {|page| b << page.path}
             b << target
           end
           converted_pages.each do |temp_file|
@@ -197,29 +210,37 @@ module Libis
         def convert_image(source, target, format)
 
           image_info = nil
-          image_info = MiniMagick::Image::Info.new(source) if @wm_image
+          image_info = MiniMagick::Image::Info.new(source) {|b| b.quiet} if @wm_image
 
           MiniMagick::Tool::Convert.new do |convert|
+            convert.quiet if @quiet
             if @wm_image
               convert << @wm_image.path
+              convert.bordercolor('transparent').border("#{@wm_gap}%") if @wm_gap > 0
               convert.filter('Lagrange')
-              convert.resize("#{image_info['width'] / @wm_size}x#{image_info['height'] / @wm_size}").write('mpr:watermark').delete.+
+              convert.resize("#{image_info['width'] / @wm_tiles}x#{image_info['height'] / @wm_tiles}") if @wm_tiles > 0
+              convert.resize("#{@wm_resize}%") if @wm_resize
+              convert.write('mpr:watermark').delete.+
             end
 
+            convert.quiet if @quiet
             convert << source
-            convert.flatten if format == :JPG
+            convert.flatten if @options[:flatten].nil? && format == :JPG
             if @wm_image
-              # noinspection RubyResolve
-              convert.stack do |stack|
-                stack.size("#{image_info['width']}x#{image_info['height']}")
-                stack << 'xc:transparent'
-                stack.tile('mpr:watermark')
-                stack.draw "rectangle 0,0,#{image_info['width']},#{image_info['height']}"
+              if @wm_tiles >= 0 and @wm_tiles <= 1
+                convert << 'mpr:watermark'
+              else
+                convert.stack do |stack|
+                  stack.size("#{image_info['width']}x#{image_info['height']}")
+                  stack << 'xc:transparent'
+                  stack.tile('mpr:watermark')
+                  stack.draw "rectangle 0,0,#{image_info['width']},#{image_info['height']}"
+                end
               end
-              convert.compose(@wm_composition).define("compose:args=#{@wm_opacity}").composite
+              convert.compose(@wm_composition).gravity(@wm_gravity).define("compose:args=#{@wm_opacity}%").composite
             end
 
-            @flags.each { |f, v| v.is_a?(FalseClass) ? convert.send(f).+ : convert.send(f) }
+            @flags.each {|f, v| v.is_a?(TrueClass) ? convert.send(f).+ : convert.send(f)}
             if @delete_date
               convert << '+set' << 'modify-date' << '+set' << 'create-date'
             end
@@ -227,13 +248,15 @@ module Libis
             colorspace = @options.delete(:colorspace) || 'sRGB'
             unless @options.empty?
               convert.colorspace('RGB')
-              @options.each { |o, v| convert.send(o, v) }
+              @options.each {|o, v| convert.send(o, v)}
             end
             convert.colorspace(colorspace)
             convert.profile @profile if @profile
 
             convert.format(format)
             convert << target
+
+            debug "ImageMagick command: '#{convert.command.join(' ')}'"
           end
 
           target

data/lib/libis/format/identifier.rb

@@ -42,10 +42,10 @@ module Libis
 
       def get(file, options = {})
 
-        options[:droid] = true unless options.keys.include?(:droid) and options[:tool] and options[:tool] != :droid
-        options[:fido] = true unless options.keys.include?(:fido) and options[:tool] and options[:tool] != :fido
-        options[:file] = true unless options.keys.include?(:file) and options[:tool] and options[:tool] != :file
-        options[:xml_validation] = true unless options.keys.include?(:xml_validation) and !options[:xml_validation]
+        options[:droid] = true unless options.keys.include?(:droid) or (options[:tool] and options[:tool] != :droid)
+        options[:fido] = true unless options.keys.include?(:fido) or (options[:tool] and options[:tool] != :fido)
+        options[:file] = true unless options.keys.include?(:file) or (options[:tool] and options[:tool] != :file)
+        options[:xml_validation] = true if options[:xml_validation].nil?
 
         result = {messages: [], output: {}, formats: {}}
 

data/lib/libis/format/type_database.rb

@@ -1,23 +1,18 @@
 # coding: utf-8
 
-require 'singleton'
 require 'yaml'
 
 require 'backports/rails/hash'
-require 'libis/tools/logger'
-require 'libis/tools/extend/string'
-
-require_relative 'config'
 
 module Libis
   module Format
 
+    # noinspection RubyClassVariableUsageInspection
     class TypeDatabase
-      include Singleton
-      include ::Libis::Tools::Logger
+      @implementation = Libis::Format::TypeDatabaseImpl.instance
 
-      def self.typeinfo(t)
-        self.instance.types[t.to_sym] || {}
+      def self.implementation(impl)
+        @implementation = impl
       end
 
       def self.enrich(info, map_keys = {})
@@ -34,7 +29,7 @@ module Libis
           mapper.keys.each do |key|
             info[mapper[key]] = get(type_name, key) || info[mapper[key]]
           end
-          info[mapper[:GROUP]] = self.type_group(type_name)
+          info[mapper[:GROUP]] = type_group(type_name)
         end
         info
       end
@@ -44,14 +39,14 @@ module Libis
         mapper = Hash.new {|hash,key| hash[key] = key}
         mapper.merge! map_keys
         unless (puid = info[mapper[:PUID]]).blank?
-          info[mapper[:TYPE]] ||= self.puid_infos(puid).first[:TYPE] rescue nil
+          info[mapper[:TYPE]] ||= puid_infos(puid).first[:TYPE] rescue nil
         end
         unless (mime = info[mapper[:MIME]]).blank?
-          info[mapper[:TYPE]] ||= self.mime_infos(mime).first[:TYPE] rescue nil
+          info[mapper[:TYPE]] ||= mime_infos(mime).first[:TYPE] rescue nil
         end
         unless (type_name = info[mapper[:TYPE]]).nil?
-          info[mapper[:MIME]] = self.type_mimetypes(type_name).first if self.type_mimetypes(type_name).first
-          info[mapper[:GROUP]] = self.type_group(type_name)
+          info[mapper[:MIME]] = type_mimetypes(type_name).first if type_mimetypes(type_name).first
+          info[mapper[:GROUP]] = type_group(type_name)
         end
         info
       end
@@ -65,7 +60,7 @@ module Libis
           when :EXTENSION
             type_extentions(type_name).first
           else
-            self.typeinfo(type_name)[key]
+            typeinfo(type_name)[key]
         end
       end
 
@@ -85,114 +80,52 @@ module Libis
         typeinfo(t)[:EXTENSIONS] || []
       end
 
+      def self.typeinfo(t)
+        @implementation.typeinfo(t)
+      end
+
       def self.group_types(group)
-        self.instance.types.select do |_, v|
-          v[:GROUP] == group.to_sym
-        end.keys
+        @implementation.group_types(group)
       end
 
       def self.puid_infos(puid)
-        self.instance.types.select do |_, v|
-          v[:PUID].include? puid rescue false
-        end.values
+        @implementation.puid_infos(puid)
       end
 
       def self.puid_types(puid)
-        self.instance.types.select do |_, v|
-          v[:PUID].include? puid rescue false
-        end.keys
+        @implementation.puid_types(puid)
       end
 
       def self.puid_groups(puid)
-        puid_types(puid).map do |t|
-          type_group t
-        end
+        puid_types(puid).map(&method(:type_group))
       end
 
       def self.mime_infos(mime)
-        self.instance.types.select do |_, v|
-          v[:MIME].include? mime rescue false
-        end.values
+        @implementation.mime_infos(mime)
       end
 
       def self.mime_types(mime)
-        self.instance.types.select do |_, v|
-          v[:MIME].include? mime rescue false
-        end.keys
+        @implementation.mime_types(mime)
       end
 
       def self.mime_groups(mime)
-        mime_types(mime).map do |t|
-          type_group t
-        end
+        mime_types(mime).map(&method(:type_group))
       end
 
       def self.ext_infos(ext)
-        ext = ext.gsub /^\./, ''
-        self.instance.types.select do |_, v|
-          v[:EXTENSIONS].include?(ext) rescue false
-        end.values
+        @implementation.ext_infos(ext)
       end
 
       def self.ext_types(ext)
-        ext = ext.gsub /^\./, ''
-        self.instance.types.select do |_, v|
-          v[:EXTENSIONS].include?(ext) rescue false
-        end.keys
+        @implementation.ext_types(ext)
       end
 
       def self.puid_typeinfo(puid)
-        self.instance.types.each do |_, v|
-          return v if v[:PUID] and v[:PUID].include?(puid)
-        end
-        nil
+        @implementation.puid_typeinfo(puid)
       end
 
       def self.known_mime?(mime)
-        self.instance.types.each do |_, v|
-          return true if v[:MIME].include? mime
-        end
-        false
-      end
-
-      attr_reader :types
-
-      def load_types(file_or_hash = {}, append = true)
-        hash = file_or_hash.is_a?(Hash) ? file_or_hash : YAML::load_file(file_or_hash)
-        # noinspection RubyResolve
-        hash.each do |group, type_info|
-          type_info.each do |type_name, info|
-            type_key = type_name.to_sym
-            info.symbolize_keys!
-            info[:TYPE] = type_key
-            info[:GROUP] = group.to_sym
-            info[:MIME] = info[:MIME].strip.split(/[\s,]+/).map { |v| v.strip } rescue []
-            info[:EXTENSIONS] = info[:EXTENSIONS].strip.split(/[\s,]+/).map { |v| v.strip } rescue []
-            info[:PUID] = info[:PUID].strip.split(/[\s,]+/).map { |v| v.strip } if info[:PUID]
-            if @types.has_key?(type_key)
-              warn 'Type %s already defined; merging with info from %s.', type_name.to_s, file_or_hash
-              info.merge!(@types[type_key]) do |_,v_new,v_old|
-                case v_old
-                  when Array
-                    append ? v_old + v_new : v_new + v_old
-                  when Hash
-                    append ? v_new.merge(v_old) : v_old.merge(v_new)
-                  else
-                    append ? v_old : v_new
-                end
-              end
-            end
-            @types[type_key] = info
-          end
-        end
-      end
-
-      protected
-
-      def initialize
-        @types = Hash.new
-        type_database = Libis::Format::Config[:type_database]
-        load_types(type_database)
+        @implementation.known_mime?(mime)
       end
 
     end

data/lib/libis/format/type_database_impl.rb

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+require 'singleton'
+require 'yaml'
+
+require 'backports/rails/hash'
+require 'libis/tools/logger'
+require 'libis/tools/extend/string'
+
+module Libis
+  module Format
+
+    class TypeDatabaseImpl
+      include Singleton
+      include ::Libis::Tools::Logger
+
+      def typeinfo(t)
+        @types[t.to_sym] || {}
+      end
+
+      def group_types(group)
+        @types.select do |_, v|
+          v[:GROUP] == group.to_sym
+        end.keys
+      end
+
+      def puid_infos(puid)
+        @types.select do |_, v|
+          v[:PUID].include? puid rescue false
+        end.values
+      end
+
+      def puid_types(puid)
+        @types.select do |_, v|
+          v[:PUID].include? puid rescue false
+        end.keys
+      end
+
+      def mime_infos(mime)
+        @types.select do |_, v|
+          v[:MIME].include? mime rescue false
+        end.values
+      end
+
+      def mime_types(mime)
+        @types.select do |_, v|
+          v[:MIME].include? mime rescue false
+        end.keys
+      end
+
+      def ext_infos(ext)
+        ext = ext.gsub /^\./, ''
+        @types.select do |_, v|
+          v[:EXTENSIONS].include?(ext) rescue false
+        end.values
+      end
+
+      def ext_types(ext)
+        ext = ext.gsub /^\./, ''
+        @types.select do |_, v|
+          v[:EXTENSIONS].include?(ext) rescue false
+        end.keys
+      end
+
+      def puid_typeinfo(puid)
+        @types.each do |_, v|
+          return v if v[:PUID] and v[:PUID].include?(puid)
+        end
+        nil
+      end
+
+      def known_mime?(mime)
+        @types.each do |_, v|
+          return true if v[:MIME].include? mime
+        end
+        false
+      end
+
+      def load_types(file_or_hash = {}, append = true)
+        hash = file_or_hash.is_a?(Hash) ? file_or_hash : YAML::load_file(file_or_hash)
+        # noinspection RubyResolve
+        hash.each do |group, type_info|
+          type_info.each do |type_name, info|
+            type_key = type_name.to_sym
+            info.symbolize_keys!
+            info[:TYPE] = type_key
+            info[:GROUP] = group.to_sym
+            info[:MIME] = info[:MIME].strip.split(/[\s,]+/).map(&:strip) rescue []
+            info[:EXTENSIONS] = info[:EXTENSIONS].strip.split(/[\s,]+/).map { |v| v.strip } rescue []
+            info[:PUID] = info[:PUID].strip.split(/[\s,]+/).map { |v| v.strip } if info[:PUID]
+            if @types.has_key?(type_key)
+              warn 'Type %s already defined; merging with info from %s.', type_name.to_s, file_or_hash
+              info.merge!(@types[type_key]) do |_,v_new,v_old|
+                case v_old
+                when Array
+                  append ? v_old + v_new : v_new + v_old
+                when Hash
+                  append ? v_new.merge(v_old) : v_old.merge(v_new)
+                else
+                  append ? v_old : v_new
+                end
+              end
+            end
+            @types[type_key] = info
+          end
+        end
+      end
+
+      protected
+
+      def initialize
+        @types = Hash.new
+        type_database = Libis::Format::Config[:type_database]
+        load_types(type_database)
+      end
+
+    end
+
+  end
+end

data/lib/libis/format/version.rb

@@ -1,5 +1,5 @@
 module Libis
   module Format
-    VERSION = '1.0.2'
+    VERSION = '1.0.4'
   end
 end

data/libis-format.gemspec

@@ -22,7 +22,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake', '~> 10.3'
   spec.add_development_dependency 'rspec', '~> 3.1'
   spec.add_development_dependency 'awesome_print'

data/spec/identifier_spec.rb

@@ -12,7 +12,7 @@ formatlist =
         'test.odt' => {mimetype: 'application/vnd.oasis.opendocument.text', puid: 'fmt/291'},
         'test.doc' => {mimetype: 'application/msword', puid: 'fmt/40'},
         'test.docx' => {mimetype: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', puid: 'fmt/412'},
-        'test.pdf' => {mimetype: 'application/pdf', puid: 'fmt/18'},
+        'test.pdf' => {mimetype: 'application/pdf', puid: 'fmt/276'},
         'test.rtf' => {mimetype: 'application/rtf', puid: 'fmt/45'},
         'test.txt' => {mimetype: 'text/plain', puid: 'x-fmt/111'},
         'test.ods' => {mimetype: 'application/vnd.oasis.opendocument.spreadsheet', puid: 'fmt/295'},
@@ -42,7 +42,7 @@ fidolist =
         'test.odt' => {mimetype: 'application/vnd.oasis.opendocument.text', puid: 'fmt/290'},
         'test.doc' => {mimetype: nil, puid: 'fmt/111'},
         'test.docx' => {mimetype: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', puid: 'fmt/412'},
-        'test.pdf' => {mimetype: 'application/pdf', puid: 'fmt/18'},
+        'test.pdf' => {mimetype: 'application/pdf', puid: 'fmt/276'},
         'test.rtf' => {mimetype: 'application/rtf', puid: 'fmt/45'},
         'test.txt' => {mimetype: 'text/plain', puid: 'x-fmt/111'},
         'test.ods' => {mimetype: 'application/vnd.oasis.opendocument.spreadsheet', puid: 'fmt/294'},

data/spec/type_database_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 describe 'Type Databse' do
 
   before :all do
-    ::Libis::Format::TypeDatabase.instance.load_types File.join(File.dirname(__FILE__), 'test_types.yml')
+    ::Libis::Format::TypeDatabaseImpl.instance.load_types File.join(File.dirname(__FILE__), 'test_types.yml')
   end
 
   it 'should load types from file' do
@@ -93,7 +93,7 @@ describe 'Type Databse' do
 
   it 'should load types from hash' do
 
-    ::Libis::Format::TypeDatabase.instance.load_types TESTMEDIUM: {
+    ::Libis::Format::TypeDatabaseImpl.instance.load_types TESTMEDIUM: {
                                                           TESTREPORT: {
                                                               NAME: 'Test report format',
                                                               MIME: 'test/report application/test/report',
@@ -111,7 +111,7 @@ describe 'Type Databse' do
 
   it 'should merge types from hash' do
 
-    ::Libis::Format::TypeDatabase.instance.load_types TESTMEDIUM: {
+    ::Libis::Format::TypeDatabaseImpl.instance.load_types TESTMEDIUM: {
                                                           TESTREPORT: {
                                                               EXTENSIONS: 'rpt'
                                                           }
@@ -123,7 +123,7 @@ describe 'Type Databse' do
                                                                      MIME: %w'test/report application/test/report',
                                                                      EXTENSIONS: %w'rep rpt'
 
-    ::Libis::Format::TypeDatabase.instance.load_types({TESTMEDIUM: {
+    ::Libis::Format::TypeDatabaseImpl.instance.load_types({TESTMEDIUM: {
                                                           TESTREPORT: {
                                                               EXTENSIONS: 'report'
                                                           }

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: libis-format
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.4
 platform: ruby
 authors:
 - Kris Dekeyser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-15 00:00:00.000000000 Z
+date: 2019-01-22 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -186,6 +172,7 @@ executables:
 - droid
 - fido
 - formatinfo
+- libis_format
 - pdf_copy
 extensions: []
 extra_rdoc_files: []
@@ -200,6 +187,7 @@ files:
 - bin/droid
 - bin/fido
 - bin/formatinfo
+- bin/libis_format
 - bin/pdf_copy
 - data/ISOcoated_v2_eci.icc
 - data/PDFA_def.ps
@@ -210,6 +198,11 @@ files:
 - data/xlink.xsd
 - lib/libis-format.rb
 - lib/libis/format.rb
+- lib/libis/format/cli/convert.rb
+- lib/libis/format/cli/format.rb
+- lib/libis/format/cli/prompt_helper.rb
+- lib/libis/format/cli/sub_command.rb
+- lib/libis/format/command_line.rb
 - lib/libis/format/config.rb
 - lib/libis/format/converter.rb
 - lib/libis/format/converter/audio_converter.rb
@@ -242,6 +235,7 @@ files:
 - lib/libis/format/tool/pdfa_validator.rb
 - lib/libis/format/tool/spreadsheet_to_ods.rb
 - lib/libis/format/type_database.rb
+- lib/libis/format/type_database_impl.rb
 - lib/libis/format/version.rb
 - libis-format.gemspec
 - spec/converter_audio_spec.rb