libis-format 1.3.2 → 2.0.0

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'os'
-
-require 'libis/tools/extend/string'
-require 'libis/tools/logger'
-require 'libis/tools/command'
-
-require 'libis/format/config'
-
-module Libis
-  module Format
-    module Tool
-      class PdfTool
-        include ::Libis::Tools::Logger
-
-        def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:java_cmd], '-version')
-          return false unless (result[:status]).zero?
-
-          File.exist?(Libis::Format::Config[:pdf_tool])
-        end
-
-        def self.run(command, source, target, *options)
-          new.run command, source, target, *options
-        end
-
-        def run(command, source, target, *options)
-          if OS.java?
-            # TODO: import library and execute in current VM. For now do exactly as in MRI.
-          end
-
-          timeout = Libis::Format::Config[:timeouts][:pdf_tool]
-          args = [
-            Libis::Format::Config[:java_cmd],
-            '-jar', Libis::Format::Config[:pdf_tool],
-            [command],
-            '-i', source,
-            '-o', target,
-            options,
-          ].flatten
-
-          result = Libis::Tools::Command.run(*args, timeout: , kill_after: timeout * 2)
-
-          result[:err] << "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
-
-          result
-        end
-      end
-    end
-  end
-end

data/lib/libis/format/type_database.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'libis/tools/extend/hash'
-
-module Libis
-  module Format
-    # noinspection RubyClassVariableUsageInspection
-    class TypeDatabase
-      @implementation = Libis::Format::TypeDatabaseImpl.instance
-
-      def self.implementation(impl)
-        @implementation = impl
-      end
-
-      def self.enrich(info, map_keys = {})
-        return {} unless info.is_a? Hash
-
-        mapper = Hash.new { |hash, key| hash[key] = key }
-        mapper.merge! map_keys
-        unless (puid = info[mapper[:PUID]]).blank?
-          info[mapper[:TYPE]] ||= begin
-            puid_infos(puid).first[:TYPE]
-          rescue StandardError
-            nil
-          end
-        end
-        unless (mime = info[mapper[:MIME]]).blank?
-          info[mapper[:TYPE]] ||= begin
-            mime_infos(mime).first[:TYPE]
-          rescue StandardError
-            nil
-          end
-        end
-        unless (type_name = info[mapper[:TYPE]]).nil?
-          mapper.each_key do |key|
-            info[mapper[key]] = get(type_name, key) || info[mapper[key]]
-          end
-          info[mapper[:GROUP]] = type_group(type_name)
-        end
-        info
-      end
-
-      def self.normalize(info, map_keys = {})
-        return {} unless info.is_a? Hash
-
-        mapper = Hash.new { |hash, key| hash[key] = key }
-        mapper.merge! map_keys
-        unless (puid = info[mapper[:PUID]]).blank?
-          info[mapper[:TYPE]] ||= begin
-            puid_infos(puid).first[:TYPE]
-          rescue StandardError
-            nil
-          end
-        end
-        unless (mime = info[mapper[:MIME]]).blank?
-          info[mapper[:TYPE]] ||= begin
-            mime_infos(mime).first[:TYPE]
-          rescue StandardError
-            nil
-          end
-        end
-        unless (type_name = info[mapper[:TYPE]]).nil?
-          info[mapper[:MIME]] = type_mimetypes(type_name).first if type_mimetypes(type_name).first
-          info[mapper[:GROUP]] = type_group(type_name)
-        end
-        info
-      end
-
-      def self.get(type_name, key)
-        case key
-        when :MIME
-          type_mimetypes(type_name).first
-        when :PUID
-          type_puids(type_name).first
-        when :EXTENSION
-          type_extentions(type_name).first
-        else
-          typeinfo(type_name)[key]
-        end
-      end
-
-      def self.type_group(ftype)
-        typeinfo(ftype)[:GROUP]
-      end
-
-      def self.type_mimetypes(ftype)
-        typeinfo(ftype)[:MIME] || []
-      end
-
-      def self.type_puids(ftype)
-        typeinfo(ftype)[:PUID] || []
-      end
-
-      def self.type_extentions(ftype)
-        typeinfo(ftype)[:EXTENSIONS] || []
-      end
-
-      def self.typeinfo(ftype)
-        @implementation.typeinfo(ftype)
-      end
-
-      def self.group_types(group)
-        @implementation.group_types(group)
-      end
-
-      def self.puid_infos(puid)
-        @implementation.puid_infos(puid)
-      end
-
-      def self.puid_types(puid)
-        @implementation.puid_types(puid)
-      end
-
-      def self.puid_groups(puid)
-        puid_types(puid).map(&method(:type_group))
-      end
-
-      def self.mime_infos(mime)
-        @implementation.mime_infos(mime)
-      end
-
-      def self.mime_types(mime)
-        @implementation.mime_types(mime)
-      end
-
-      def self.mime_groups(mime)
-        mime_types(mime).map(&method(:type_group))
-      end
-
-      def self.ext_infos(ext)
-        @implementation.ext_infos(ext)
-      end
-
-      def self.ext_types(ext)
-        @implementation.ext_types(ext)
-      end
-
-      def self.puid_typeinfo(puid)
-        @implementation.puid_typeinfo(puid)
-      end
-
-      def self.known_mime?(mime)
-        @implementation.known_mime?(mime)
-      end
-
-      def self.groups
-        @implementation.groups
-      end
-
-      def self.export_csv(filename, **options)
-        @implementation.export_csv(filename, **options)
-      end
-    end
-  end
-end

data/lib/libis/format/type_database_impl.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-require 'yaml'
-require 'csv'
-
-require 'libis/tools/logger'
-require 'libis/tools/extend/hash'
-require 'libis/tools/extend/string'
-require 'libis/tools/extend/symbol'
-
-module Libis
-  module Format
-    class TypeDatabaseImpl
-      include Singleton
-      include ::Libis::Tools::Logger
-
-      def typeinfo(ftype)
-        @types[ftype.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 StandardError
-          false
-        end.values
-      end
-
-      def puid_types(puid)
-        @types.select do |_, v|
-          v[:PUID].include? puid
-        rescue StandardError
-          false
-        end.keys
-      end
-
-      def mime_infos(mime)
-        @types.select do |_, v|
-          v[:MIME].include? mime
-        rescue StandardError
-          false
-        end.values
-      end
-
-      def mime_types(mime)
-        @types.select do |_, v|
-          v[:MIME].include? mime
-        rescue StandardError
-          false
-        end.keys
-      end
-
-      def ext_infos(ext)
-        ext = ext.gsub(/^\./, '')
-        @types.select do |_, v|
-          v[:EXTENSIONS].include?(ext)
-        rescue StandardError
-          false
-        end.values
-      end
-
-      def ext_types(ext)
-        ext = ext.gsub(/^\./, '')
-        @types.select do |_, v|
-          v[:EXTENSIONS].include?(ext)
-        rescue StandardError
-          false
-        end.keys
-      end
-
-      def puid_typeinfo(puid)
-        @types.each do |_, v|
-          return v if 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 groups
-        @types.values.map(&:dig.with(:GROUP)).uniq
-      end
-
-      def export_csv(filename, **options)
-        headers = @types.values.each_with_object(Set.new) { |v, s| v.each_key { |k| s << k.to_s } }
-        options[:headers] = headers.to_a
-        CSV.open(filename, 'w', **options) do |csv|
-          @types.each_value do |v|
-            csv << CSV::Row.new(v.keys, v.values.map { |x| x.is_a?(Array) ? x.join(', ') : x })
-          end
-        end
-      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] = begin
-              info[:MIME].strip.split(/[\s,]+/).map(&:strip)
-            rescue StandardError
-              []
-            end
-            info[:EXTENSIONS] = begin
-              info[:EXTENSIONS].strip.split(/[\s,]+/).map(&:strip)
-            rescue StandardError
-              []
-            end
-            info[:PUID] = info[:PUID].strip.split(/[\s,]+/).map(&:strip) if info[:PUID]
-            if @types.key?(type_key)
-              warn 'Type %s already defined; merging with info from %s.', type_name, 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 = {}
-        type_database = Libis::Format::Config[:type_database]
-        load_types(type_database)
-      end
-    end
-  end
-end