libis-format 1.0.4 → 2.0.2

data/lib/libis/format/type_database.rb

@@ -1,134 +0,0 @@
-# coding: utf-8
-
-require 'yaml'
-
-require 'backports/rails/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]] ||= puid_infos(puid).first[:TYPE] rescue nil
-        end
-        unless (mime = info[mapper[:MIME]]).blank?
-          info[mapper[:TYPE]] ||= mime_infos(mime).first[:TYPE] rescue nil
-        end
-        unless (type_name = info[mapper[:TYPE]]).nil?
-          mapper.keys.each 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]] ||= puid_infos(puid).first[:TYPE] rescue nil
-        end
-        unless (mime = info[mapper[:MIME]]).blank?
-          info[mapper[:TYPE]] ||= mime_infos(mime).first[:TYPE] rescue nil
-        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(t)
-        typeinfo(t)[:GROUP]
-      end
-
-      def self.type_mimetypes(t)
-        typeinfo(t)[:MIME] || []
-      end
-
-      def self.type_puids(t)
-        typeinfo(t)[:PUID] || []
-      end
-
-      def self.type_extentions(t)
-        typeinfo(t)[:EXTENSIONS] || []
-      end
-
-      def self.typeinfo(t)
-        @implementation.typeinfo(t)
-      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
-
-    end
-
-  end
-end

data/lib/libis/format/type_database_impl.rb

@@ -1,120 +0,0 @@
-# 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/spec/converter_audio_spec.rb

@@ -1,66 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-require 'libis/format/converter/audio_converter'
-
-describe 'Converters' do
-
-  let(:repository) {Libis::Format::Converter::Repository}
-  let(:file_dir) {File.dirname(__FILE__)}
-
-  before(:all) {
-    Libis::Tools::Config.logger.level = 'off'
-  }
-
-  context 'Audio Converter' do
-
-    let(:converter) {Libis::Format::Converter::AudioConverter.new}
-    extensions = %w'aac aiff au flac m4a mka mp3 ra voc wav wma'
-    confidence = {
-        aac: 0.86,
-        aiff: 0.99,
-        au: 0.99,
-        flac: 0.99,
-        m4a: 0.93,
-        mka: 0.94,
-        mp3: 0.95,
-        ra: 0.92,
-        voc: 0.99,
-        wav: 0.99,
-        wma: 0.9
-    }
-    targets = %w'mp3 flac wav'
-    sources = %w'carlin_disappointed greensleeves king_nonviolence top_gun_secret'
-    quality = {
-        carlin_disappointed: 1.0,
-        greensleeves: 0.95,
-        king_nonviolence: 1.0,
-        top_gun_secret: 0.95
-    }
-
-    let(:data_dir) {File.join(file_dir, 'data', 'audio')}
-
-    context 'converts' do
-      sources.each do |source|
-        extensions.each do |ext|
-          next unless (File.exists?(File.join(File.dirname(__FILE__), 'data', 'audio', "#{source}.#{ext}")))
-          (targets - [ext]).each do |tgt|
-            it "#{source} #{ext} to #{tgt}" do
-              src_file = File.join(data_dir, "#{source}.#{ext}")
-              ref_file = File.join(data_dir, "#{source}.#{tgt}")
-              tgt_file = File.join('', 'tmp', "test.#{source}.#{ext}.#{tgt}")
-              FileUtils.remove tgt_file, force: true
-              FileUtils.mkdir_p File.dirname(tgt_file)
-              result = converter.convert(src_file, tgt_file, tgt.upcase.to_sym)
-              expect(result).to eq tgt_file
-              expect(result).to sound_like ref_file, confidence[ext.to_sym] * quality[source.to_sym], 11025, 1
-              FileUtils.remove tgt_file, force: true
-            end
-          end
-        end
-      end
-    end
-
-  end
-
-end

data/spec/converter_fop_spec.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-require 'fileutils'
-require 'rspec/matchers'
-
-require 'libis/format/converter/fop_pdf_converter'
-
-describe 'Converters' do
-
-  let(:repository) {Libis::Format::Converter::Repository}
-  let(:file_dir) {File.dirname(__FILE__)}
-
-  before(:all) {
-    Libis::Tools::Config.logger.level = 'error'
-  }
-
-  context 'Apache FOP-PDF Converter' do
-
-    let(:converter) {Libis::Format::Converter::FopPdfConverter.new}
-    let(:data_dir) {File.join(file_dir, 'data', 'xml')}
-
-    it 'converts XML-FO to PDF' do
-      if File.exist?(Libis::Format::Config[:fop_jar])
-        src_file = File.join data_dir, '134476_fo.XML'
-        tgt_file = File.join '', 'tmp', '134476_ead.pdf'
-        cmp_file = File.join data_dir, '134476_ead.pdf'
-        FileUtils.remove tgt_file, force: true
-        FileUtils.mkdir_p File.dirname(tgt_file)
-        result = converter.convert src_file, tgt_file, :PDF
-        expect(result).to eq tgt_file
-      end
-    end
-
-  end
-
-end

data/spec/converter_image_spec.rb

@@ -1,166 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-require 'libis/format/converter/image_converter'
-require 'libis/format/converter/jp2_converter'
-
-describe 'Converters' do
-
-  let(:repository) {Libis::Format::Converter::Repository}
-  let(:file_dir) {File.dirname(__FILE__)}
-
-  before(:all) {
-    Libis::Tools::Config.logger.level = 'off'
-  }
-
-  context 'Image Converter' do
-
-    let(:converter) {Libis::Format::Converter::ImageConverter.new}
-    let(:diff_file) {File.join('', 'tmp', 'diff.jpg')}
-
-    it 'converts TIFF to JPEG' do
-      src_file = File.join(file_dir, 'data', 'test.tif')
-      ref_file = File.join(file_dir, 'data', 'test.jpg')
-      tgt_file = File.join('', 'tmp', 'test.jpg')
-      FileUtils.mkdir_p File.dirname(tgt_file)
-      converter.delete_date
-      result = converter.convert(src_file, tgt_file, :JPG)
-      expect(result).to eq tgt_file
-      compare = MiniMagick::Tool::Compare.new
-      compare << ref_file << tgt_file
-      compare.metric << 'MAE'
-      compare.fuzz << '1%'
-      compare << diff_file
-      compare.call {|_, _, status| expect(status).to be 0}
-      FileUtils.rm tgt_file, force: true
-      FileUtils.rm diff_file, force: true
-    end
-
-    it 'converts TIFF to PNG' do
-      src_file = File.join(file_dir, 'data', 'test.tif')
-      ref_file = File.join(file_dir, 'data', 'test.png')
-      tgt_file = File.join('', 'tmp', 'test.png')
-      FileUtils.mkdir_p File.dirname(tgt_file)
-      converter.delete_date
-      converter.page(0)
-      result = converter.convert(src_file, tgt_file, :PNG)
-      expect(result).to eq tgt_file
-      compare = MiniMagick::Tool::Compare.new
-      compare << ref_file << tgt_file
-      compare.metric << 'MAE'
-      compare << diff_file
-      compare.call {|_, _, status| expect(status).to be 0}
-      FileUtils.rm tgt_file, force: true
-      FileUtils.rm diff_file, force: true
-    end
-
-    it 'converts PDF to TIFF' do
-      src_file = File.join(file_dir, 'data', 'test.pdf')
-      ref_file = File.join(file_dir, 'data', 'test.pdf.tif')
-      tgt_file = File.join('', 'tmp', 'test.pdf.tif')
-      FileUtils.mkdir_p File.dirname(tgt_file)
-      converter.delete_date
-      result = converter.convert(src_file, tgt_file, :TIFF)
-      expect(result).to eq tgt_file
-      compare = MiniMagick::Tool::Compare.new
-      compare << ref_file << tgt_file
-      compare.metric << 'AE'
-      compare.fuzz << '100%'
-      compare << diff_file
-      compare.call {|_, _, status| expect(status).to be 0}
-      FileUtils.rm tgt_file, force: true
-      FileUtils.rm diff_file, force: true
-    end
-
-    it 'converts TIFF to PNG with many options' do
-      src_file = File.join(file_dir, 'data', 'test.tif')
-      ref_file = File.join(file_dir, 'data', 'test-options.png')
-      tgt_file = File.join('', 'tmp', 'test-options.png')
-      FileUtils.mkdir_p File.dirname(tgt_file)
-      converter.watermark(text: 'RSPEC', size: 5, opacity: 0.1, rotation: 15, gap: 0.5, composition: 'modulate')
-      converter.delete_date
-      result = converter.convert(src_file, tgt_file, :PNG, options: {scale: '150%'})
-      expect(result).to eq tgt_file
-      compare = MiniMagick::Tool::Compare.new
-      compare << ref_file << tgt_file
-      compare.metric << 'AE'
-      compare.fuzz << '100%'
-      compare << diff_file
-      compare.call do |_stdin, _stdout, status|
-        expect(status).to be 0
-      end
-      FileUtils.rm tgt_file, force: true
-      FileUtils.rm diff_file, force: true
-    end
-
-    it 'converts only first page of multipage TIFF to JP2' do
-      src_file = File.join(file_dir, 'data', 'multipage.tif')
-      ref_file = File.join(file_dir, 'data', 'multipage.tif.jp2')
-      tgt_file = File.join('', 'tmp', 'test.jp2')
-      FileUtils.mkdir_p File.dirname(tgt_file)
-      converter.delete_date
-      converter.quiet(true)
-      converter.page(0)
-      result = converter.convert(src_file, tgt_file, :JP2)
-      expect(result).to eq tgt_file
-      expect(File.exist?(tgt_file)).to be_truthy
-      compare = MiniMagick::Tool::Compare.new
-      compare << ref_file << tgt_file
-      compare.metric << 'MAE'
-      compare.fuzz << '10%'
-      compare << diff_file
-      compare.call {|_, _, status| expect(status).to be 0}
-      FileUtils.rm tgt_file, force: true
-      FileUtils.rm diff_file, force: true
-    end
-
-    it 'converts TIFF to JP2' do
-      src_file = File.join(file_dir, 'data', 'test.tif')
-      tgt_file = File.join('', 'tmp', 'test.jp2')
-      FileUtils.mkdir_p File.dirname(tgt_file)
-      converter.delete_date
-      result = converter.convert(src_file, tgt_file, :JP2)
-      expect(result).to eq tgt_file
-      expect(File.exist?(tgt_file)).to be_truthy
-      FileUtils.rm tgt_file, force: true
-    end
-
-
-  end
-
-  context 'JP2 Converter', if: File.exists?(Libis::Format::Config[:j2kdriver]) do
-
-    let(:converter) {Libis::Format::Converter::Jp2Converter.new}
-    let(:diff_file) {File.join('', 'tmp', 'diff.jpg')}
-
-    it 'converts TIFF to JP2' do
-      src_file = File.join(file_dir, 'data', 'test.tif')
-      tgt_file = File.join('', 'tmp', 'test.jp2')
-      FileUtils.mkdir_p File.dirname(tgt_file)
-      result = converter.convert(src_file, tgt_file, :JP2)
-      expect(result).to eq tgt_file
-      expect(File.exist?(tgt_file)).to be_truthy
-      FileUtils.rm tgt_file, force: true
-    end
-
-    it 'converts only first page of multipage TIFF to JP2' do
-      src_file = File.join(file_dir, 'data', 'multipage.tif')
-      ref_file = File.join(file_dir, 'data', 'multipage.tif.jp2')
-      tgt_file = File.join('', 'tmp', 'test.jp2')
-      FileUtils.mkdir_p File.dirname(tgt_file)
-      result = converter.convert(src_file, tgt_file, :JP2)
-      expect(result).to eq tgt_file
-      expect(File.exist?(tgt_file)).to be_truthy
-      compare = MiniMagick::Tool::Compare.new
-      compare << ref_file << tgt_file
-      compare.metric << 'MAE'
-      compare.fuzz << '10%'
-      compare << diff_file
-      compare.call {|_, _, status| expect(status).to be 0}
-      FileUtils.rm tgt_file, force: true
-      FileUtils.rm diff_file, force: true
-    end
-
-  end
-
-end