libis-format 1.0.4 → 2.0.2

data/spec/identifier_spec.rb

@@ -1,161 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'libis/format/identifier'
-require 'awesome_print'
-
-# noinspection RubyStringKeysInHashInspection
-formatlist =
-    {
-        'Cevennes2.ppm' => {mimetype: 'image/x-portable-pixmap', puid: 'fmt/408'},
-        'Cevennes2.bmp' => {mimetype: 'image/bmp', puid: 'fmt/116'},
-        'Cevennes2.jp2' => {mimetype: 'image/jp2', puid: 'x-fmt/392'},
-        '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/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'},
-        'test.xls' => {mimetype: 'application/vnd.ms-excel', puid: 'fmt/61'},
-        'test.xlsx' => {mimetype: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', puid: 'fmt/214'},
-        'test.psd' => {mimetype: 'image/vnd.adobe.photoshop', puid: 'x-fmt/92'},
-        'test.bmp' => {mimetype: 'image/bmp', puid: 'fmt/119'},
-        'test.tif' => {mimetype: 'image/tiff', puid: 'fmt/353'},
-        'test-jpg.tif' => {mimetype: 'image/tiff', puid: 'fmt/353'},
-        'test-lzw.tif' => {mimetype: 'image/tiff', puid: 'fmt/353'},
-        'test.ps' => {mimetype: 'application/postscript', puid: 'x-fmt/408'},
-        'test.png' => {mimetype: 'image/png', puid: 'fmt/11'},
-        'test.jpg' => {mimetype: 'image/jpeg', puid: 'fmt/43'},
-        'test.gif' => {mimetype: 'image/gif', puid: 'fmt/4'},
-        'test.xml' => {mimetype: 'text/xml', puid: 'fmt/101'},
-        'test-ead.xml' => {mimetype: 'archive/ead', puid: 'fmt/101'},
-        'NikonRaw-CaptureOne.tif' => {mimetype: 'image/tiff', puid: 'x-fmt/387'},
-        'NikonRaw-CameraRaw.TIF' => {mimetype: 'image/tiff', puid: 'fmt/353'},
-    }
-
-# noinspection RubyStringKeysInHashInspection
-fidolist =
-    {
-        'Cevennes2.ppm' => {mimetype: 'image/x-portable-pixmap', puid: 'fmt/408'},
-        'Cevennes2.bmp' => {mimetype: 'image/bmp', puid: 'fmt/116'},
-        'Cevennes2.jp2' => {mimetype: 'image/jp2', puid: 'x-fmt/392'},
-        '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/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'},
-        'test.xls' => {mimetype: 'application/vnd.ms-excel', puid: 'fmt/61'},
-        'test.xlsx' => {mimetype: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', puid: 'fmt/214'},
-        'test.psd' => {mimetype: 'image/vnd.adobe.photoshop', puid: 'x-fmt/92'},
-        'test.bmp' => {mimetype: 'image/bmp', puid: 'fmt/119'},
-        'test.tif' => {mimetype: 'image/tiff', puid: 'fmt/353'},
-        'test-jpg.tif' => {mimetype: 'image/tiff', puid: 'fmt/353'},
-        'test-lzw.tif' => {mimetype: 'image/tiff', puid: 'fmt/353'},
-        'test.ps' => {mimetype: 'application/postscript', puid: 'x-fmt/408'},
-        'test.png' => {mimetype: 'image/png', puid: 'fmt/11'},
-        'test.jpg' => {mimetype: 'image/jpeg', puid: 'fmt/43'},
-        'test.gif' => {mimetype: 'image/gif', puid: 'fmt/4'},
-        'test.xml' => {mimetype: 'text/xml', puid: 'fmt/101'},
-        'test-ead.xml' => {mimetype: 'text/xml', puid: 'fmt/101'},
-        'NikonRaw-CaptureOne.tif' => {mimetype: 'image/tiff', puid: 'fmt/353'},
-        'NikonRaw-CameraRaw.TIF' => {mimetype: 'image/tiff', puid: 'fmt/353'},
-    }
-
-describe 'Identfier' do
-
-  before :all do
-    ::Libis::Tools::Config.logger.appenders =
-        ::Logging::Appenders.string_io('StringIO', layout: ::Libis::Tools::Config.get_log_formatter)
-    ::Libis::Tools::Config.logger.level = :all
-  end
-
-  let (:identifier) {::Libis::Format::Identifier}
-  let (:logoutput) {::Libis::Tools::Config.logger.appenders.last.sio}
-  let (:dir) {File.join File.absolute_path(File.dirname(__FILE__)), 'data'}
-
-  it 'should initialize correctly' do
-    expect(identifier.xml_validations.size).to be 1
-    expect(File.basename identifier.xml_validations['archive/ead']).to eq 'ead.xsd'
-  end
-
-  # noinspection RubyResolve
-  it 'should not attempt to identify a non-existing file or directory' do
-    result = identifier.get (File.join(dir, 'abcdef'))
-    expect(result[:output]).to be_empty
-    expect(result[:formats]).to be_empty
-    expect(result[:messages]).not_to be_empty
-    expect(result[:messages].all? do |x|
-      x[0] == :error &&
-          x[1] =~ /^Error running (Droid|Fido|File): IdentificationTool: file argument should be a path to an existing file or directory or a list of those/
-    end).to be_truthy
-  end
-
-  context 'Fido and Droid', if: (File.exists?(Libis::Format::Config[:droid_path]) &&
-      File.exists?(Libis::Format::Config[:fido_path])) do
-
-    it 'should identify all files in a folder at once' do
-      result = identifier.get(dir)
-      expect(result[:formats].size).to be >= formatlist.size
-      formatlist.each do |file, format|
-        expect(result[:formats][File.join(dir, file)]).to include format
-      end
-    end
-
-    it 'should identify all files in a folder with base_dir option' do
-      result = identifier.get(dir, base_dir: dir, keep_output: true)
-      expect(result[:formats].size).to be >= formatlist.size
-      formatlist.each do |file, format|
-        expect(result[:formats][file]).to include format
-      end
-    end
-
-    it 'should identify all files in a list at once' do
-      filelist = fidolist.keys.map {|file| File.join(dir, file)}
-      result = identifier.get (filelist)
-      expect(result[:formats].size).to be >= formatlist.size
-      formatlist.each do |file, format|
-        expect(result[:formats][File.join(dir, file)]).to include format
-      end
-    end
-
-    it 'should identify all files in a list with base_dir option' do
-      filelist = fidolist.keys.map {|file| File.join(dir, file)}
-      result = identifier.get(filelist, base_dir: dir)
-      expect(result[:formats].size).to be >= formatlist.size
-      formatlist.each do |file, format|
-        expect(result[:formats][file]).to include format
-      end
-    end
-
-  end
-
-  context 'Fido', if: File.exists?(Libis::Format::Config[:fido_path]) do
-
-    # expect(identifier.fido_formats.size).to be 1
-    # expect(File.basename(identifier.fido_formats.first)).to eq 'lias_formats.xml'
-    it 'should identify list of test documents' do
-      filelist = formatlist.keys.map {|file| File.join(dir, file)}
-      fido_result = ::Libis::Format::Tool::Fido.instance.run_list(filelist)
-      filelist.each do |filename|
-        result = fido_result[filename]
-        result = result[0] if result
-        # noinspection RubyResolve
-        expect(result).to include fidolist[File.basename(filename)]
-      end
-    end
-
-    it 'should identify dir of test documents' do
-      filelist = fidolist.keys.map {|file| File.join(dir, file)}
-      fido_result = ::Libis::Format::Tool::Fido.instance.run_dir(dir, false)
-      filelist.each do |filename|
-        result = fido_result[filename]
-        result = result[0] if result
-        # noinspection RubyResolve
-        expect(result).to include fidolist[File.basename(filename)]
-      end
-    end
-
-  end
-end

data/spec/spec_helper.rb

@@ -1,58 +0,0 @@
-require 'coveralls'
-Coveralls.wear!
-
-require 'bundler/setup'
-Bundler.setup
-
-require 'rspec'
-require 'libis-format'
-require 'libis-tools'
-
-require 'chromaprint'
-
-RSpec::Matchers.define(:be_same_file_as) do |exected_file_path|
-  match do |actual_file_path|
-    expect(md5_hash(actual_file_path)).to eq md5_hash(exected_file_path)
-  end
-
-  def md5_hash(file_path)
-    Digest::MD5.hexdigest(File.read(file_path))
-  end
-end
-
-RSpec::Matchers.define :sound_like do |exp_file, threshold, rate, channels|
-  match do |tgt_file|
-    rate ||= 96000
-    channels ||= 1
-    threshold ||= 0.9
-
-    if File.exists?(exp_file) && File.exists?(tgt_file)
-      # Convert input files into raw 16-bit signed audio (WAV) to process with Chramaprint
-      exp_raw = File.join('','tmp', File.basename(exp_file) + '.wav')
-      tgt_raw = File.join('','tmp', File.basename(tgt_file) + '.wav')
-      FileUtils.rm(exp_raw, force: true)
-      FileUtils.rm(tgt_raw, force: true)
-      cvt_cmd = "sox %s -e signed -b 16 -t wav %s rate #{rate} channels #{channels}"
-      %x"#{cvt_cmd % [exp_file,exp_raw]}"
-      %x"#{cvt_cmd % [tgt_file,tgt_raw]}"
-      exp_audio = File.binread(exp_raw)
-      tgt_audio = File.binread(tgt_raw)
-
-      # Get audio fingerprints
-      chromaprint = Chromaprint::Context.new(rate, channels, Chromaprint::ALGORITHM_TEST3)
-      exp_fp = chromaprint.get_fingerprint(exp_audio)
-      tgt_fp = chromaprint.get_fingerprint(tgt_audio)
-
-      # Cleanup files
-      FileUtils.rm(exp_raw, force: true)
-      FileUtils.rm(tgt_raw, force: true)
-
-      # Compare fingerprints and compare result against threshold
-      cmp = exp_fp.compare(tgt_fp)
-      # puts "Threshold[#{File.basename(exp_file)},#{File.basename(tgt_file)}: #{cmp}"
-      cmp > threshold
-    else
-      false
-    end
-  end
-end

data/spec/test_types.yml

@@ -1,12 +0,0 @@
-TESTMEDIUM:
-  TESTDATA:
-    NAME: Test data format
-    MIME: test/data, application/test/data
-    PUID: test-fmt/001 spec-fmt/101
-    EXTENSIONS: dat data
-
-  TESTSPEC:
-    NEW: Test specification format
-    MIME: test/spec application/test/spec
-    PUID: test-fmt/002 spec-fmt/102
-    EXTENSIONS: spc,spec

data/spec/type_database_spec.rb

@@ -1,140 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe 'Type Databse' do
-
-  before :all do
-    ::Libis::Format::TypeDatabaseImpl.instance.load_types File.join(File.dirname(__FILE__), 'test_types.yml')
-  end
-
-  it 'should load types from file' do
-
-    expect(::Libis::Format::TypeDatabase.typeinfo :TESTDATA).to eq GROUP: :TESTMEDIUM,
-                                                                   TYPE: :TESTDATA,
-                                                                   NAME: 'Test data format',
-                                                                   PUID: %w'test-fmt/001 spec-fmt/101',
-                                                                   MIME: %w'test/data application/test/data',
-                                                                   EXTENSIONS: %w'dat data'
-    expect(::Libis::Format::TypeDatabase.typeinfo :TESTSPEC).to eq GROUP: :TESTMEDIUM,
-                                                                   TYPE: :TESTSPEC,
-                                                                   NEW: 'Test specification format',
-                                                                   PUID: %w'test-fmt/002 spec-fmt/102',
-                                                                   MIME: %w'test/spec application/test/spec',
-                                                                   EXTENSIONS: %w'spc spec'
-  end
-
-  it 'should get the type\'s group' do
-
-    expect(::Libis::Format::TypeDatabase.type_group :TESTDATA).to eq :TESTMEDIUM
-    expect(::Libis::Format::TypeDatabase.type_group :TESTSPEC).to eq :TESTMEDIUM
-
-  end
-
-  it 'should get the type\'s puids' do
-
-    expect(::Libis::Format::TypeDatabase.type_puids :TESTDATA).to eq %w'test-fmt/001 spec-fmt/101'
-    expect(::Libis::Format::TypeDatabase.type_puids :TESTSPEC).to eq %w'test-fmt/002 spec-fmt/102'
-
-  end
-
-  it 'should get the type\'s mimetypes' do
-
-    expect(::Libis::Format::TypeDatabase.type_mimetypes :TESTDATA).to eq %w'test/data application/test/data'
-    expect(::Libis::Format::TypeDatabase.type_mimetypes :TESTSPEC).to eq %w'test/spec application/test/spec'
-
-  end
-
-  it 'should get the type\'s extensions' do
-
-    expect(::Libis::Format::TypeDatabase.type_extentions :TESTDATA).to eq %w'dat data'
-    expect(::Libis::Format::TypeDatabase.type_extentions :TESTSPEC).to eq %w'spc spec'
-
-  end
-
-  it 'should get the group\'s types' do
-
-    expect(::Libis::Format::TypeDatabase.group_types :TESTMEDIUM).to eq [:TESTDATA, :TESTSPEC]
-
-  end
-
-  it 'should get the mimetype\'s types' do
-
-    expect(::Libis::Format::TypeDatabase.mime_types 'test/data').to eq [:TESTDATA]
-    expect(::Libis::Format::TypeDatabase.mime_types 'application/test/data').to eq [:TESTDATA]
-    expect(::Libis::Format::TypeDatabase.mime_types 'test/spec').to eq [:TESTSPEC]
-    expect(::Libis::Format::TypeDatabase.mime_types 'application/test/spec').to eq [:TESTSPEC]
-
-  end
-
-  it 'should get the mimetype\'s groups' do
-
-    expect(::Libis::Format::TypeDatabase.mime_groups 'test/data').to eq [:TESTMEDIUM]
-    expect(::Libis::Format::TypeDatabase.mime_groups 'application/test/data').to eq [:TESTMEDIUM]
-    expect(::Libis::Format::TypeDatabase.mime_groups 'test/spec').to eq [:TESTMEDIUM]
-    expect(::Libis::Format::TypeDatabase.mime_groups 'application/test/spec').to eq [:TESTMEDIUM]
-
-  end
-
-  it 'should get the extension\'s types' do
-
-    expect(::Libis::Format::TypeDatabase.ext_types 'dat').to eq [:TESTDATA]
-    expect(::Libis::Format::TypeDatabase.ext_types 'data').to eq [:TESTDATA]
-    expect(::Libis::Format::TypeDatabase.ext_types 'spc').to eq [:TESTSPEC]
-    expect(::Libis::Format::TypeDatabase.ext_types 'spec').to eq [:TESTSPEC]
-
-  end
-
-  it 'should check if mimetype is known' do
-
-    expect(::Libis::Format::TypeDatabase.known_mime? 'test/data').to be_truthy
-    expect(::Libis::Format::TypeDatabase.known_mime? 'test/spec').to be_truthy
-
-  end
-
-  it 'should load types from hash' do
-
-    ::Libis::Format::TypeDatabaseImpl.instance.load_types TESTMEDIUM: {
-                                                          TESTREPORT: {
-                                                              NAME: 'Test report format',
-                                                              MIME: 'test/report application/test/report',
-                                                              EXTENSIONS: 'rep'
-                                                          }
-                                                      }
-
-    expect(::Libis::Format::TypeDatabase.typeinfo :TESTREPORT).to eq GROUP: :TESTMEDIUM,
-                                                                     TYPE: :TESTREPORT,
-                                                                     NAME: 'Test report format',
-                                                                     MIME: %w'test/report application/test/report',
-                                                                     EXTENSIONS: %w'rep'
-
-  end
-
-  it 'should merge types from hash' do
-
-    ::Libis::Format::TypeDatabaseImpl.instance.load_types TESTMEDIUM: {
-                                                          TESTREPORT: {
-                                                              EXTENSIONS: 'rpt'
-                                                          }
-                                                      }
-
-    expect(::Libis::Format::TypeDatabase.typeinfo :TESTREPORT).to eq GROUP: :TESTMEDIUM,
-                                                                     TYPE: :TESTREPORT,
-                                                                     NAME: 'Test report format',
-                                                                     MIME: %w'test/report application/test/report',
-                                                                     EXTENSIONS: %w'rep rpt'
-
-    ::Libis::Format::TypeDatabaseImpl.instance.load_types({TESTMEDIUM: {
-                                                          TESTREPORT: {
-                                                              EXTENSIONS: 'report'
-                                                          }
-                                                      }}, false)
-
-    expect(::Libis::Format::TypeDatabase.typeinfo :TESTREPORT).to eq GROUP: :TESTMEDIUM,
-                                                                     TYPE: :TESTREPORT,
-                                                                     NAME: 'Test report format',
-                                                                     MIME: %w'test/report application/test/report',
-                                                                     EXTENSIONS: %w'report rep rpt'
-
-  end
-
-end