libis-tools 1.0.5-java

data/libis-tools.gemspec

@@ -0,0 +1,55 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'libis/tools/version'
+require 'date'
+
+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.platform      = Gem::Platform::JAVA if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.bindir        = 'bin'
+  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.has_rdoc = 'yard'
+
+  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 'term-ansicolor', '~> 1.6'
+  spec.add_development_dependency 'equivalent-xml', '~> 0.5'
+  spec.add_development_dependency 'awesome_print', '~> 1.6'
+
+  spec.add_runtime_dependency 'backports', '~> 3.6'
+  spec.add_runtime_dependency 'nokogiri', '~> 1.6'
+  spec.add_runtime_dependency 'gyoku',  '~> 1.3'
+  spec.add_runtime_dependency 'nori', '~> 2.6'
+  spec.add_runtime_dependency 'recursive-open-struct', '~> 1.0'
+  spec.add_runtime_dependency 'parslet', '~> 1.7'
+  spec.add_runtime_dependency 'simple_xlsx_reader', '~> 1.0'
+  spec.add_runtime_dependency 'logging', '~> 2.0'
+  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
+  spec.add_runtime_dependency 'yard', '~> 0.9.11'
+  spec.add_runtime_dependency 'roo', '~> 2.5'
+  spec.add_runtime_dependency 'roo-xls', '~> 1.0'
+  spec.add_runtime_dependency 'tty-prompt'
+  spec.add_runtime_dependency 'tty-config'
+  spec.add_runtime_dependency 'thor'
+
+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,68 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/checksum'
+
+describe 'Checksum' do
+
+  def hex2base64(hexdigest)
+    [[hexdigest].pack('H*')].pack('m0')
+  end
+
+  def hex2string(hexdigest)
+    [hexdigest].pack('H*')
+  end
+
+  it 'should not know how to calculate ABC checksum' do
+
+    checksum_type = :ABC
+
+    expect {
+      ::Libis::Tools::Checksum.hexdigest('abc', checksum_type)
+    }.to raise_error(RuntimeError, "Checksum type 'ABC' not supported.")
+
+  end
+
+  let(:filename) { File.join(File.dirname(__FILE__), 'data', 'test.data') }
+
+  CHECKSUM_RESULTS = {
+      MD5: 'fe249d8dd45a39793f315fb0734ffe2c',
+      SHA1: 'e8f322d186699807a98a0cefb5015acf1554f954',
+      SHA256: '2a742e643dd79427738bdc0ebd0d2837f998fe2101a964c2d5014905d331bbc4',
+      SHA384: '71083b74394f49db6149ad9147103f7693ec823183750ce32a2215bbd7ee5e75212e2d794243c7e76c7318a4ddcf9a56',
+      SHA512: '10964f5272729c2670ccad67754284fb06cca1387270c184c2edbcd032700548297916c8e109a10e019c25b86c646e95a3456c465f83d571502889f97b483e6f'
+  }
+
+  # noinspection RubyResolve
+  unless defined? JRUBY_VERSION
+    CHECKSUM_RESULTS[:RMD160] = '17c9eaad9ccbaad0e030c2c5d60fd9d58255cc39'
+  end
+
+  filename = File.join(File.dirname(__FILE__), 'data', 'test.data')
+  file = File.absolute_path(filename)
+  string = File.read(filename)
+  SUBJECTS = {
+      string: string,
+      file: file
+  }
+
+  CHECKSUM_RESULTS.each do |checksum_type, digest|
+
+    SUBJECTS.each do |subject_type, subject|
+
+      it "should calculate #{checksum_type} from #{subject_type}" do
+        expect(::Libis::Tools::Checksum.hexdigest(subject, checksum_type)).to eq digest
+        expect(::Libis::Tools::Checksum.base64digest(subject, checksum_type)).to eq hex2base64(digest)
+        expect(::Libis::Tools::Checksum.digest(subject, checksum_type)).to eq hex2string(digest)
+
+        checksum = ::Libis::Tools::Checksum.new(checksum_type)
+
+        expect(checksum.hexdigest(subject)).to eq digest
+        expect(checksum.base64digest(subject)).to eq hex2base64(digest)
+        expect(checksum.digest(subject)).to eq hex2string(digest)
+      end
+
+    end
+
+  end
+
+end

data/spec/command_spec.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/command'
+
+describe 'Command' do
+
+  let!(:dir) { Dir.pwd }
+  let(:entries) {
+    Dir.entries('.').inject([]) do |array, value|
+      array << value unless File.directory?(value)
+      array
+    end.sort
+  }
+
+  before(:each) { Dir.chdir(File.join(File.dirname(__FILE__),'data')) }
+  after(:each) { Dir.chdir(dir) }
+
+  it 'should run ls command' do
+
+    result = Libis::Tools::Command.run('ls')
+
+    output = result[:out].map {|x| x.split(/\s+/)}.flatten.compact
+    expect(output.size).to eq entries.size
+    expect(output.sort).to match entries
+    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', '-1')
+
+    output = result[:out]
+    puts output.sort
+    expect(output.size).to eq entries.size
+    expect(output.sort).to match entries
+    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', '-1', '-a', '-p')
+
+    output = result[:out]
+    expect(output.size).to eq entries.size + 2
+    expect(output[0]).to eq './'
+    expect(output[1]).to eq '../'
+    expect(output[2..-1].sort).to match entries
+    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
+
+  it 'should allow to supply input data' do
+
+    result = Libis::Tools::Command.run('cat', stdin_data: "FooBar", timeout: 1)
+    expect(result[:out]).to eq ['FooBar']
+    expect(result[:err].size).to eq 0
+    expect(result[:status]).to eq 0
+
+  end
+
+  it 'should not timeout if command finishes' do
+
+    result = Libis::Tools::Command.run('cat', stdin_data: "FooBar", timeout: 1)
+    expect(result[:timeout]).to be_falsey
+
+  end
+
+  it 'should timeout if command hangs' do
+
+    result = Libis::Tools::Command.run('ls', '-aRlp', '/', timeout: 1)
+    expect(result[:timeout]).to be_truthy
+
+  end
+
+end

data/spec/config_file_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/config_file'
+
+describe ::Libis::Tools::ConfigFile do
+
+  let!(:test_file) { File.join(File.dirname(__FILE__), 'data', 'test_config.yml') }
+
+  let(:hash) {
+    {
+        a: {x: 0, y: 0, z: 0},
+        b: {x: 10, y: -5, z: 2.5},
+        c: [
+            [
+                {a: [{a1: 1, a2: 2}]},
+            ]
+        ]
+    }
+  }
+
+  context 'after default initialization' do
+
+    it 'has empty hash' do
+      # noinspection RubyResolve
+      expect(subject.to_hash).to be_empty
+    end
+
+    it 'loads from file' do
+      subject << test_file
+      expect(subject.to_hash).to eq hash
+    end
+
+    it 'loads a hash' do
+      subject << hash
+      expect(subject.to_hash).to eq hash
+    end
+
+    it 'allows to change sub-hash' do
+      subject << hash
+      # noinspection RubyResolve
+      subject.b.v = 1
+      hash[:b][:v] = 1
+      expect(subject.to_hash).to eq hash
+    end
+
+    it 'allows to change hash in array' do
+      subject << hash
+      # noinspection RubyResolve
+      subject.c[0][0].a[0].v = 1
+      hash[:c][0][0][:a][0][:v] = 1
+      expect(subject.to_hash).to eq hash
+    end
+
+  end
+
+  context 'initialization with hash' do
+    subject { ::Libis::Tools::ConfigFile.new hash }
+
+    it 'has hash' do
+      expect(subject.to_hash).to eq hash
+    end
+
+  end
+
+  context 'initialization with file' do
+    subject { ::Libis::Tools::ConfigFile.new test_file }
+
+    it 'has hash' do
+      expect(subject.to_hash).to eq hash
+    end
+
+  end
+
+  context 'initialization with hash from YAML file' do
+    subject { ::Libis::Tools::ConfigFile.new YAML.load_file(test_file)}
+
+    it 'has hash' do
+      expect(subject.to_hash).to eq hash
+    end
+
+  end
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/config'
+
+describe 'Config' do
+
+  before(:all) do
+    ::Libis::Tools::Config << {appname: 'LIBIS Default'}
+  end
+
+  subject(:config) { ::Libis::Tools::Config.clear! }
+
+  it 'has defaults set' do
+    expect(config.logger).to be_a ::Logging::Logger
+  end
+
+  it 'clears all values' do
+    # noinspection RubyResolve
+    config.test_value = 5
+    config.logger.level = :FATAL
+    # noinspection RubyResolve
+    expect(config.test_value).to be 5
+    expect(config.logger.level).to be ::Logging::level_num(:FATAL)
+
+    config.clear!
+    # noinspection RubyResolve
+    expect(config.test_value).to be_nil
+  end
+
+  context 'adding values with setters' do
+
+    it 'by symbol' do
+      config[:test_value] = 5
+      expect(config['test_value']).to be 5
+    end
+
+    it 'by name' do
+      config['test_value'] = 6
+      # noinspection RubyResolve
+      expect(config.test_value).to be 6
+    end
+
+    it 'by method' do
+      # noinspection RubyResolve
+      config.test_value = 7
+      expect(config[:test_value]).to be 7
+    end
+
+    it 'allows to set on instance' do
+      config.instance[:test_value] = :abc
+      # noinspection RubyResolve
+      expect(config.test_value).to be :abc
+    end
+
+    it 'allows to set on class' do
+      # noinspection RubyResolve
+      config.test_value = :def
+      expect(config.instance[:test_value]).to be :def
+    end
+
+  end
+
+  context 'loading from file' do
+
+    let(:test_file) { File.join(File.dirname(__FILE__), 'data', 'test.yml') }
+    subject(:config) {
+      Libis::Tools::Config.clear! << test_file
+    }
+
+    it 'has configuration parameters set' do
+      expect(config.process).to eq 'Test Configuration'
+    end
+
+    it 'resets only values loaded from file' do
+      config[:process] = 'foo'
+      config[:bar] = 'qux'
+
+      expect(config.process).to eq 'foo'
+      expect(config.bar).to eq 'qux'
+
+      config.reload
+      expect(config.process).to eq 'Test Configuration'
+      expect(config.bar).to eq 'qux'
+    end
+
+    it 'resets all values' do
+      config[:process] = 'foo'
+      config[:bar] = 'qux'
+
+      expect(config.process).to eq 'foo'
+      expect(config.bar).to eq 'qux'
+
+      config.reload!
+      expect(config.process).to eq 'Test Configuration'
+      expect(config.bar).to be_nil
+    end
+
+    it 'clears all values' do
+      config[:process] = 'foo'
+      config[:bar] = 'qux'
+
+      expect(config.process).to eq 'foo'
+      expect(config.bar).to eq 'qux'
+
+      config.clear!
+      expect(config.process).to be_nil
+      expect(config.bar).to be_nil
+      # noinspection RubyResolve
+      expect(config.to_h).to be_empty
+    end
+
+  end
+end