libis-tools 0.9.1

data/libis-tools.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'libis/tools/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'libis-tools'
+  spec.version       = ::Libis::Tools::VERSION
+  spec.date          = Date.today.to_s
+
+  spec.summary       = %q{LIBIS toolbox.}
+  spec.description   = %q{Some tool classes for other LIBIS gems.}
+
+  spec.authors       = ['Kris Dekeyser']
+  spec.email         = ['kris.dekeyser@libis.be']
+  spec.homepage      = 'https://github.com/Kris-LIBIS/LIBIS_Tools'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  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 'simplecov', '~> 0.9'
+  spec.add_development_dependency 'equivalent-xml', '~> 0.5'
+
+  spec.add_runtime_dependency 'backports', '~> 3.6'
+  spec.add_runtime_dependency 'savon', '~> 2.0'
+  spec.add_runtime_dependency 'nokogiri', '~> 1.6'
+  spec.add_runtime_dependency 'gyoku',  '~> 1.2'
+  spec.add_runtime_dependency 'nori', '~> 2.4'
+
+end

data/spec/assert_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/assert'
+
+describe 'Assert' do
+
+  before :example do
+    $DEBUG = true
+  end
+
+  after :example do
+    $DEBUG = false
+  end
+
+  it 'should throw an assert exception when statement is false' do
+
+    message = 'Testing the assert with false.'
+    expect {
+      assert(false, message)
+    }.to raise_error(AssertionFailure, message)
+
+  end
+
+  it 'should only throw an assert in debug mode' do
+
+    $DEBUG = false
+    expect {
+      assert(false, 'Testing the assert with false.')
+    }.to_not raise_error
+
+  end
+
+  it 'should not throw an assert if statement is true' do
+
+    expect {
+      assert(true, 'Testing the assert with true.')
+    }.to_not raise_error
+
+  end
+
+  it 'should throw an assert on nil' do
+
+    message = 'Testing the assert with nil.'
+    expect {
+      assert(nil, message)
+    }.to raise_error(AssertionFailure, message)
+  end
+
+  it 'should check the given block if present' do
+
+    message = 'block test'
+    expect {
+      assert(message) do
+        false
+      end
+    }.to raise_error(AssertionFailure, message)
+
+    expect {
+      assert(message) do
+        true
+      end
+    }.to_not raise_error
+
+  end
+end

data/spec/checksum_spec.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/checksum'
+
+describe 'Checksum' do
+
+  file = File.absolute_path(File.join(File.dirname(__FILE__), 'data', 'test.data'))
+
+  def hex2base64(hexdigest)
+    [[hexdigest].pack('H*')].pack('m0')
+  end
+
+  def hex2string(hexdigest)
+    [hexdigest].pack('H*')
+  end
+
+  it 'should calculate MD5 checksum' do
+
+    checksum_type = :MD5
+    digest = 'fe249d8dd45a39793f315fb0734ffe2c'
+    expect(::Libis::Tools::Checksum.hexdigest(file, checksum_type)).to eq digest
+    expect(::Libis::Tools::Checksum.base64digest(file, checksum_type)).to eq hex2base64(digest)
+    expect(::Libis::Tools::Checksum.digest(file, checksum_type)).to eq hex2string(digest)
+
+    checksum = ::Libis::Tools::Checksum.new(checksum_type)
+
+    expect(checksum.hexdigest(file)).to eq digest
+    expect(checksum.base64digest(file)).to eq hex2base64(digest)
+    expect(checksum.digest(file)).to eq hex2string(digest)
+
+  end
+
+  it 'should calculate RMD160 checksum' do
+
+    unless defined? JRUBY_VERSION
+
+      checksum_type = :RMD160
+
+      digest = '17c9eaad9ccbaad0e030c2c5d60fd9d58255cc39'
+      expect(::Libis::Tools::Checksum.hexdigest(file, checksum_type)).to eq digest
+      expect(::Libis::Tools::Checksum.base64digest(file, checksum_type)).to eq hex2base64(digest)
+      expect(::Libis::Tools::Checksum.digest(file, checksum_type)).to eq hex2string(digest)
+
+      checksum = ::Libis::Tools::Checksum.new(checksum_type)
+
+      expect(checksum.hexdigest(file)).to eq digest
+      expect(checksum.base64digest(file)).to eq hex2base64(digest)
+      expect(checksum.digest(file)).to eq hex2string(digest)
+
+    end
+
+  end
+
+  it 'should calculate SHA1 checksum' do
+
+    checksum_type = :SHA1
+
+    digest = 'e8f322d186699807a98a0cefb5015acf1554f954'
+    expect(::Libis::Tools::Checksum.hexdigest(file, checksum_type)).to eq digest
+    expect(::Libis::Tools::Checksum.base64digest(file, checksum_type)).to eq hex2base64(digest)
+    expect(::Libis::Tools::Checksum.digest(file, checksum_type)).to eq hex2string(digest)
+
+    checksum = ::Libis::Tools::Checksum.new(checksum_type)
+
+    expect(checksum.hexdigest(file)).to eq digest
+    expect(checksum.base64digest(file)).to eq hex2base64(digest)
+    expect(checksum.digest(file)).to eq hex2string(digest)
+
+  end
+
+  it 'should calculate SHA256 checksum' do
+
+    checksum_type = :SHA256
+
+    digest = '2a742e643dd79427738bdc0ebd0d2837f998fe2101a964c2d5014905d331bbc4'
+    expect(::Libis::Tools::Checksum.hexdigest(file, checksum_type)).to eq digest
+    expect(::Libis::Tools::Checksum.base64digest(file, checksum_type)).to eq hex2base64(digest)
+    expect(::Libis::Tools::Checksum.digest(file, checksum_type)).to eq hex2string(digest)
+
+    checksum = ::Libis::Tools::Checksum.new(checksum_type)
+
+    expect(checksum.hexdigest(file)).to eq digest
+    expect(checksum.base64digest(file)).to eq hex2base64(digest)
+    expect(checksum.digest(file)).to eq hex2string(digest)
+
+  end
+
+  it 'should calculate SHA384 checksum' do
+
+    checksum_type = :SHA384
+
+    digest = '71083b74394f49db6149ad9147103f7693ec823183750ce32a2215bbd7ee5e75212e2d794243c7e76c7318a4ddcf9a56'
+    expect(::Libis::Tools::Checksum.hexdigest(file, checksum_type)).to eq digest
+    expect(::Libis::Tools::Checksum.base64digest(file, checksum_type)).to eq hex2base64(digest)
+    expect(::Libis::Tools::Checksum.digest(file, checksum_type)).to eq hex2string(digest)
+
+    checksum = ::Libis::Tools::Checksum.new(checksum_type)
+
+    expect(checksum.hexdigest(file)).to eq digest
+    expect(checksum.base64digest(file)).to eq hex2base64(digest)
+    expect(checksum.digest(file)).to eq hex2string(digest)
+
+  end
+
+  it 'should calculate SHA512 checksum' do
+
+    checksum_type = :SHA512
+
+    digest = '10964f5272729c2670ccad67754284fb06cca1387270c184c2edbcd032700548297916c8e109a10e019c25b86c646e95a3456c465f83d571502889f97b483e6f'
+    expect(::Libis::Tools::Checksum.hexdigest(file, checksum_type)).to eq digest
+    expect(::Libis::Tools::Checksum.base64digest(file, checksum_type)).to eq hex2base64(digest)
+    expect(::Libis::Tools::Checksum.digest(file, checksum_type)).to eq hex2string(digest)
+
+    checksum = ::Libis::Tools::Checksum.new(checksum_type)
+
+    expect(checksum.hexdigest(file)).to eq digest
+    expect(checksum.base64digest(file)).to eq hex2base64(digest)
+    expect(checksum.digest(file)).to eq hex2string(digest)
+
+  end
+
+  it 'should not know how to calculate ABC checksum' do
+
+    checksum_type = :ABC
+
+    expect {
+      ::Libis::Tools::Checksum.hexdigest(file, checksum_type)
+    }.to raise_error(RuntimeError, "Checksum type 'ABC' not supported.")
+
+  end
+
+end

data/spec/command_spec.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/command'
+
+describe 'Command' do
+
+  around(:example) do |test|
+    dir = Dir.pwd
+    Dir.chdir(File.join(File.dirname(__FILE__),'data'))
+    test.run
+    Dir.chdir(dir)
+  end
+
+  it 'should run ls command' do
+
+    result = Libis::Tools::Command.run('ls')
+
+    expect(result[:out]).to eq %w'test.data test.xml test.yml'
+    expect(result[:err]).to eq []
+    expect(result[:status]).to eq 0
+
+  end
+
+  it 'should run ls command with an option' do
+
+    result = Libis::Tools::Command.run('ls', '-l')
+
+    output = result[:out]
+    expect(output.size).to eq 4
+    expect(output.first).to match /^total \d+$/
+    expect(output[1]).to match /^-[rwx-]{9}.+test.data$/
+    expect(output[2]).to match /^-[rwx-]{9}.+test.xml$/
+    expect(output[3]).to match /^-[rwx-]{9}.+test.yml$/
+
+    expect(result[:err]).to eq []
+    expect(result[:status]).to eq 0
+
+  end
+
+  it 'should run ls command with multiple options' do
+
+    result = Libis::Tools::Command.run('ls', '-l', '-a', '-p')
+
+    output = result[:out]
+    expect(output.size).to eq 6
+    expect(output.first).to match /^total \d+$/
+    expect(output[1]).to match /^d[rwx-]{9}.+\d+.+\.\/$/
+    expect(output[2]).to match /^d[rwx-]{9}.+\d+.+\.\.\/$/
+    expect(output[3]).to match /^-[rwx-]{9}.+test.data$/
+    expect(output[4]).to match /^-[rwx-]{9}.+test.xml$/
+    expect(output[5]).to match /^-[rwx-]{9}.+test.yml$/
+
+    expect(result[:err]).to eq []
+    expect(result[:status]).to eq 0
+
+  end
+
+  it 'should capture error output and status' do
+
+    result = Libis::Tools::Command.run('ls', 'abc')
+    expect(result[:out]).to eq []
+    expect(result[:err].size).to eq 1
+    expect(result[:err][0]).to match /ls: cannot access abc: No such file or directory/
+    expect(result[:status]).to eq 2
+
+  end
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/config'
+
+describe 'Config' do
+
+  test_file = File.join(File.dirname(__FILE__), 'data', 'test.yml')
+  config = ::Libis::Tools::Config
+  config << { appname: 'LIBIS Default' }
+
+  it 'should initialize' do
+    expect(config.appname).to eq 'LIBIS Default'
+    expect(config.logger).to be_a ::Logger
+  end
+
+  # noinspection RubyResolve
+  it 'should define setters' do
+    config[:test_value] = 5
+    expect(config.test_value).to eq 5
+  end
+
+  it 'should load from file' do
+    config << test_file
+    expect(config.process).to eq 'Test Configuration'
+  end
+
+  # noinspection RubyResolve
+  it 'should allow to set and get in different ways' do
+    config.test_value = 10
+    expect(config.test_value).to be 10
+    expect(config['test_value']).to be 10
+    expect(config[:test_value]).to be 10
+    expect(config.instance.test_value).to be 10
+    expect(config.instance['test_value']).to be 10
+    expect(config.instance[:test_value]).to be 10
+
+    config[:test_value] = 11
+    expect(config.test_value).to be 11
+    expect(config['test_value']).to be 11
+    expect(config[:test_value]).to be 11
+    expect(config.instance.test_value).to be 11
+    expect(config.instance['test_value']).to be 11
+    expect(config.instance[:test_value]).to be 11
+
+    config['test_value'] = 12
+    expect(config.test_value).to be 12
+    expect(config['test_value']).to be 12
+    expect(config[:test_value]).to be 12
+    expect(config.instance.test_value).to be 12
+    expect(config.instance['test_value']).to be 12
+    expect(config.instance[:test_value]).to be 12
+  end
+
+  it 'should allow to set and get on class and instance' do
+    expect(config.appname).to be config.instance.appname
+    expect(config['appname']).to be config.instance.appname
+    expect(config[:appname]).to be config.instance.appname
+    expect(config.instance['appname']).to be config.instance.appname
+    expect(config.instance[:appname]).to be config.instance.appname
+
+    config.instance[:appname] = 'Test App'
+    expect(config.appname).to be == 'Test App'
+  end
+
+  # noinspection RubyResolve
+  it 'should reset only values loaded from file' do
+    config[:appname] = 'foo'
+    config[:process] = 'bar'
+    config[:baz] = 'qux'
+
+    expect(config.appname).to eq 'foo'
+    expect(config.process).to eq 'bar'
+    expect(config.baz).to eq 'qux'
+
+    config.reload
+    expect(config.appname).to eq 'LIBIS Default'
+    expect(config.process).to eq 'Test Configuration'
+    expect(config.baz).to eq 'qux'
+
+    config.reload!
+    expect(config.appname).to eq 'LIBIS Default'
+    expect(config.process).to eq 'Test Configuration'
+    expect(config.baz).to be_nil
+  end
+
+end

data/spec/data/test.data

@@ -0,0 +1,9 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam ultricies condimentum suscipit. Sed nec suscipit sapien. Nullam eget magna fringilla, dignissim justo quis, eleifend sapien. Maecenas quis euismod nunc. Etiam aliquam tellus quis urna pretium ornare. Cras placerat, magna imperdiet vestibulum molestie, sem ante bibendum tortor, nec dapibus augue ligula dictum mauris. In nibh lacus, pellentesque nec posuere non, lacinia et diam. Aliquam dictum, augue sed finibus feugiat, lorem arcu ullamcorper metus, non commodo metus neque sit amet elit. Suspendisse id arcu consequat, euismod leo id, tempus velit. Ut diam leo, pulvinar sed nulla nec, volutpat suscipit ligula. Vestibulum ac erat mauris. Quisque posuere lacus a rutrum faucibus. Sed convallis risus vel congue scelerisque. Vestibulum nec nunc eu massa imperdiet sagittis.
+
+Praesent quis felis congue, consequat odio vitae, rhoncus turpis. Suspendisse potenti. Donec rutrum leo vitae ex imperdiet molestie. Vivamus efficitur mi vitae sem porta, vel pretium lacus auctor. Maecenas ac finibus quam. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Vestibulum magna metus, commodo ac ligula vestibulum, aliquet volutpat lacus. Curabitur faucibus nec erat et laoreet. Suspendisse bibendum a tortor non mattis.
+
+Curabitur odio turpis, tempus in accumsan aliquet, convallis in elit. Nullam in iaculis turpis, nec pulvinar urna. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Integer mattis erat id auctor ultrices. In placerat euismod elit maximus accumsan. Nullam et enim consectetur, interdum libero sit amet, rutrum risus. Donec eleifend nec erat vel tincidunt. Maecenas pellentesque malesuada fermentum. Cras nisi dolor, dictum eu sagittis quis, consectetur suscipit mi. Cras metus ipsum, porttitor sit amet dignissim id, condimentum eget nunc. Suspendisse potenti.
+
+Fusce ante ipsum, tincidunt eget mollis sagittis, consectetur ut ligula. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Aliquam augue felis, dictum eget felis non, euismod pharetra libero. Nunc bibendum sollicitudin est vel vulputate. Maecenas et convallis erat. Nullam rutrum molestie justo, sit amet vulputate ligula commodo a. Quisque quis neque id ex sodales aliquam ac id nulla. Nunc ut ligula ut augue placerat vulputate. Donec sed volutpat nibh, et aliquam sapien. Quisque scelerisque et augue faucibus venenatis. Sed viverra, mi ut vestibulum egestas, ante metus pulvinar justo, at aliquet enim nulla eu elit. Aliquam malesuada lectus in tellus euismod, id semper metus tristique.
+
+Pellentesque tincidunt nisl ac dolor ornare feugiat. Vivamus dignissim iaculis nunc. Suspendisse et odio velit. Vivamus urna odio, tincidunt id elementum sit amet, dictum vel tortor. Vivamus rutrum magna at nibh sodales, eu venenatis lorem malesuada. Sed bibendum eros eros, vitae aliquam nunc iaculis ac. Maecenas facilisis ipsum in tellus ultricies ornare. Integer finibus eget ante eu consectetur. Nullam rutrum nunc quis sollicitudin pellentesque.

data/spec/data/test.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<patron>
+  <name>Harry Potter</name>
+  <barcode library="Hogwarts Library">1234567890</barcode>
+  <access_level>student</access_level>
+  <email>harry.potter@hogwarts.edu</email>
+  <email>hpotter@JKRowling.com</email>
+</patron>

data/spec/data/test.yml

@@ -0,0 +1 @@
+process: 'Test Configuration'

data/spec/logger_spec.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/config'
+require 'libis/tools/logger'
+
+describe 'Logger' do
+
+  class TestLogger
+    include ::Libis::Tools::Logger
+    attr_accessor :options
+    def initialize
+      @options = {}
+    end
+  end
+
+  before(:context) do
+  end
+
+  before(:example) do
+    ::Libis::Tools::Config[:appname] = ''
+    @logoutput = StringIO.new
+    ::Libis::Tools::Config.logger = ::Logger.new @logoutput
+    ::Libis::Tools::Config.logger.level = ::Logger::DEBUG
+    @test_logger = TestLogger.new
+  end
+
+  it 'should log debug output' do
+    @test_logger.debug 'Debug message'
+    output = @logoutput.string.lines.map(&:chomp)
+    expect(output.size).to eq 1
+    expect(output.first).to match /^D, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{6} #\d+\] DEBUG -- TestLogger: Debug message$/
+  end
+
+  it 'should log info output' do
+    @test_logger.info 'Info message'
+    output = @logoutput.string.lines.map(&:chomp)
+    expect(output.size).to eq 1
+    expect(output.first).to match /^I, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{6} #\d+\]  INFO -- TestLogger: Info message$/
+  end
+
+  it 'should log warning output' do
+    @test_logger.warn 'Warning message'
+    output = @logoutput.string.lines.map(&:chomp)
+    expect(output.size).to eq 1
+    expect(output.first).to match /^W, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{6} #\d+\]  WARN -- TestLogger: Warning message$/
+  end
+
+  it 'should log error output' do
+    @test_logger.error 'Error message'
+    output = @logoutput.string.lines.map(&:chomp)
+    expect(output.size).to eq 1
+    expect(output.first).to match /^E, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{6} #\d+\] ERROR -- TestLogger: Error message$/
+  end
+
+  it 'should log fatal output' do
+    @test_logger.fatal 'Fatal message'
+    output = @logoutput.string.lines.map(&:chomp)
+    expect(output.size).to eq 1
+    expect(output.first).to match /^F, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{6} #\d+\] FATAL -- TestLogger: Fatal message$/
+  end
+
+  it 'should be quiet when asked to' do
+    @test_logger.options[:quiet] = true
+
+    @test_logger.debug 'Debug message'
+    output = @logoutput.string.lines.map(&:chomp)
+    # noinspection RubyResolve
+    expect(output).to be_empty
+
+    @test_logger.info 'Info message'
+    output = @logoutput.string.lines.map(&:chomp)
+    # noinspection RubyResolve
+    expect(output).to be_empty
+
+    @test_logger.warn 'Warn message'
+    output = @logoutput.string.lines.map(&:chomp)
+    # noinspection RubyResolve
+    expect(output).to be_empty
+
+    @test_logger.error 'Error message'
+    output = @logoutput.string.lines.map(&:chomp)
+    # noinspection RubyResolve
+    expect(output).not_to be_empty
+
+    @test_logger.fatal 'Fatal message'
+    output = @logoutput.string.lines.map(&:chomp)
+    # noinspection RubyResolve
+    expect(output).not_to be_empty
+  end
+
+  it 'should display application name in log' do
+    ::Libis::Tools::Config[:appname] = 'Test Application'
+    @test_logger.info 'Info message'
+    output = @logoutput.string.lines.map(&:chomp)
+    expect(output.size).to eq 1
+    expect(output.first).to match /^I, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{6} #\d+\]  INFO -- Test Application: Info message$/
+  end
+
+  it 'should display name value in log' do
+    @test_logger.define_singleton_method(:name) { 'Logger for testing' }
+    @test_logger.info 'Info message'
+    output = @logoutput.string.lines.map(&:chomp)
+    expect(output.size).to eq 1
+    expect(output.first).to match /^I, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{6} #\d+\]  INFO -- Logger for testing: Info message$/
+  end
+
+end