libis-tools 1.0.5-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7dfb912e9b01e86323a41b92b09cfb20c1376767
+  data.tar.gz: 104aef995014cd9297ad97efd7274cbd76263c73
+SHA512:
+  metadata.gz: 221d41957c111983a162b2ff4ba2175bba747ec07fe699ce03edbbcd67c200133bb919b76921b68f754d6e14514ea8f67afa2fc5c911a655602fd1bda8570640
+  data.tar.gz: c951a929559105f46926f1570443bd53a7f944aea0a126dd2c0a5303544c1893cde798b007eb7e2e7de34486f9e60290ef0626069fc2159de0f8ea609c6071b2

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: 2ucKcCsdyh9lPHsDQ8OGVcXxGljRGmC6L

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/spec/coverage/
+/tmp/
+/.idea/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.travis.yml

@@ -0,0 +1,40 @@
+dist: bionic
+language: ruby
+cache: bundler
+sudo: false
+rvm:
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - ruby-head
+#  - jruby-9.1
+  - jruby-9.2
+  - jruby-head
+jdk:
+  - openjdk10
+  - openjdk11
+matrix:
+  exclude:
+    - rvm: 2.3
+      jdk: openjdk10
+    - rvm: 2.4
+      jdk: openjdk10
+    - rvm: 2.5
+      jdk: openjdk10
+    - rvm: 2.6
+      jdk: openjdk10
+    - rvm: ruby-head
+      jdk: openjdk10
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+branches:
+  only:
+      - master
+#before_install:
+#  - gem update --system
+#  - gem --version
+addons:
+  code_climate:
+    repo_token: f6978964f55e6543befb82373651365f8195677816af6ff40ad70c82f7f22f09

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+#gem 'codeclimate-test-reporter', group: :test, require: nil
+gem 'coveralls', group: :test, require: false
+
+# Specify your gem's dependencies in converter.gemspec
+gemspec development_group: :test

data/README.md

@@ -0,0 +1,202 @@
+[![Gem Version](https://badge.fury.io/rb/libis-tools.svg)](http://badge.fury.io/rb/libis-tools)
+[![Build Status](https://travis-ci.org/Kris-LIBIS/LIBIS_Tools.svg?branch=master)](https://travis-ci.org/Kris-LIBIS/LIBIS_Tools)
+[![Coverage Status](https://img.shields.io/coveralls/Kris-LIBIS/LIBIS_Tools.svg)](https://coveralls.io/r/Kris-LIBIS/LIBIS_Tools)
+[![Dependency Status](https://gemnasium.com/Kris-LIBIS/LIBIS_Tools.svg)](https://gemnasium.com/Kris-LIBIS/LIBIS_Tools)
+
+# Libis::Tools
+
+This gem contains some generic helper methods, classes and modules that should be easily reusable in other projects.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+    gem 'libis-tools'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install libis-tools
+
+## Usage
+
+In order to make available all the code the gem supplies a single file can be included:
+
+```ruby
+    require 'libis-tools'
+```
+
+or:
+
+```ruby
+    require 'libis/tools'
+```
+
+Alternatively, if you only want to use a single class or module, partial files are available. See the examples in the
+sections below for their names.
+
+## Content
+
+### {Object#assert}
+
+The {Object#assert} method enables the assert functionality found in other languages. Since it is defined on the
+Object class, it is available on almost any class.
+
+### {::Libis::Tools::Checksum}
+
+The {::Libis::Tools::Checksum} class offers a standardized interface for calculating checksums of file 
+contents in different formats.
+
+### {::Libis::Tools::Command}
+
+The {::Libis::Tools::Command} module offers a safe way to execute external commands and gives you access to the 
+exit status as well as standard output and standard error information. May have issues on older JRuby versions. 
+
+### {::Libis::Tools::DeepStruct}
+
+A class that derives from OpenStruct through the RecursiveOpenStruct.
+By wrapping a Hash recursively, it allows for easy access to the content by method names.
+
+### {::Libis::Tools::ConfigFile}
+
+A base class for {::Libis::Tools::Config}, but useable on it's own.
+It extends the DeepStruct with loading from and saving to YAML files.
+
+### {::Libis::Tools::Config}
+
+This Singleton class is a convenience class for easy configuration maintenance and loading.
+It also initializes a default logger.
+
+### {::Libis::Tools::Logger}
+
+The ::Libis::Tools::Logger module adds support for logging functionality to any class.
+
+## {::Libis::Tools::Parameter} and {::Libis::Tools::ParameterContainer}
+
+The class {::Libis::Tools::Parameter} and the {::Libis::Tools::ParameterContainer} module provide a simple framework for
+instance variables that are type-safe and can easily be documented and provide defaults.
+
+## {::Libis::Tools::TempFile}
+
+A small and simple module that provides some convenience methods to deal with temp files. Random file names are generated
+in a similar way as the standard Ruby Tempfile class does. It has the form:
+```
+    <Optional prefix with '_' appended><YYYYMMDD>_<process id>_<random base36 number><optional suffix>
+```
+
+The #name method creates a random file name. Optional parameters are the prefix and suffix (including '.' character if
+needed) for the temp file name and the directory part of the file path. Without directory option the file path will be
+located in the standard folder for temporary files (e.g. /tmp on Linux).
+
+The #file method creates a random file name as above, but immediately opens it for writing. If a block is given, the open
+file pointer (IO object) will be passed as argument to the block and the file will automatically be closed and deleted
+when the block ends. In that case the return value will be whatever the block returns.
+
+Without a block, the method still creates and opens the file, but it will return the open file pointer to the caller. The
+caller is responsible to #close and #unlink or #delete the file. The #unlink and #delete methods are injected into the
+returned IO object for your convenience, but calling the corresponding File methods instead is equally valid.
+
+## {::Libis::Tools::ThreadSafe}
+
+A convenience method that embeds the mutex implementation. Just include this module whenever you need a thread-save
+implementation and use the mutex instance variable without any concerns regarding initialization. Your class will have
+access to an instance variable 'mutex' as well as a class variable 'class_mutex'. The mutexes (Montor instance) themselves
+are created in a thread-safe way.
+
+## {::Libis::Tools::XmlDocument}
+
+Class that embodies most used features of Nokogiri, Nori and Gyoku in one convenience class. The Nokogiri document is
+stored in the class variable 'document' and can be accessed and manipulated directly - if required. The class supports
+the Nokogiri Build syntax for creating XML documents in a compact DSL. It also allows you to check the document against
+an XML Schema and provides shorthand notations for accessing nodes and attributes.
+
+Example:
+
+```ruby
+    xml_doc = ::Libis::Tools::XmlDocument.parse(<<-END.align_left)
+      <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>
+    END
+    puts '---parse---', xml_doc.to_xml
+    xml_doc.save('/tmp/test.xml')
+    xml_doc = ::Libis::Tools::XmlDocument.open('/tmp/test.xml')
+    puts '---save/open---', xml_doc.to_xml
+    xml_doc = ::Libis::Tools::XmlDocument.build do
+      patron {
+        name 'Harry Potter'
+        barcode( '1234567890', library: 'Hogwarts Library')
+        access_level 'student'
+        email 'harry.potter@hogwarts.edu'
+        email 'hpotter@JKRowling.com'
+      }
+    end
+    puts '---build---', xml_doc.to_xml
+    xml_doc = ::Libis::Tools::XmlDocument.new
+    xml_doc.add_node :patron
+    xml_doc.name = 'Harry Potter'
+    xml_doc.barcode = '1234567890'
+    xml_doc.barcode :library, 'Hogwarts Library'
+    xml_doc.access_level = 'student'
+    xml_doc.email = 'harry.potter@hogwarts.edu'
+    xml_doc.add_node :email, 'hpotter@JKRowling.com'
+    # Note: xml_doc.email('hpotter@JKRowling.com') whould not have created a new node.
+    #           It would override the first email element
+    puts '---method---', xml_doc.to_xml
+```
+
+produces:
+
+    ---parse---
+    <?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>
+    ---save/open---
+    <?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>
+    ---build---
+    <?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>
+    ---method---
+    <?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>
+ 
+## Contributing
+
+1. Fork it ( https://github.com/Kris-LIBIS/LIBIS_Tools/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard'
+
+RSpec::Core::RakeTask.new
+
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb']
+end
+
+task :default => :spec

data/bin/libis_tool

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'libis/tools'
+
+Libis::Tools::CommandLine.start(ARGV)

data/lib/libis-tools.rb

@@ -0,0 +1 @@
+require_relative 'libis/tools'

data/lib/libis/tools.rb

@@ -0,0 +1,25 @@
+require_relative 'tools/version'
+
+module Libis
+  module Tools
+
+    autoload :CommandLine, 'libis/tools/command_line'
+
+    autoload :Checksum, 'libis/tools/checksum'
+    autoload :Command, 'libis/tools/command'
+    autoload :Config, 'libis/tools/config'
+    autoload :ConfigFile, 'libis/tools/config_file'
+    autoload :Csv, 'libis/tools/csv'
+    autoload :DeepStruct, 'libis/tools/deep_struct'
+    autoload :Logger, 'libis/tools/logger'
+    autoload :MetsFile, 'libis/tools/mets_file'
+    autoload :Parameter, 'libis/tools/parameter'
+    autoload :Spreadsheet, 'libis/tools/spreadsheet'
+    autoload :TempFile, 'libis/tools/temp_file'
+    autoload :ThreadSafe, 'libis/tools/thread_safe'
+    autoload :XmlDocument, 'libis/tools/xml_document'
+
+  end
+end
+
+require_relative 'tools/extend/struct'

data/lib/libis/tools/assert.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+class AssertionFailure < StandardError
+end
+
+class Object
+
+  # Assert functionality as found in other languages (e.g. 'C').
+  #
+  # The assert is enabled/disabled by setting the $DEBUG global variable. If $DEBUG evaluates to true, the assertion is
+  # active.
+  #
+  # If activated, the first argument will be evaluated and when it evaluates to true, an AssertionFailure exception will
+  # be raised with the message given as the second argument.
+  #
+  # Alternatively, a code block may be passed to the assert. In that case the test expression is not evaluated, but used
+  # as the message for the expression. The assert will yield the code block and it's result will be evaluated to decide
+  # if the exception will be thrown.
+  #
+  # Examples:
+  #
+  #     require 'libis/tools/assert'
+  #     assert(value > 0, 'value should be positive number')
+  #
+  #     # using a code block:
+  #     require 'libis/tools/assert'
+  #     assert 'database is not idle' do
+  #       db = get_database
+  #       db.status == :IDLE
+  #     end
+  #
+  #     # using $DEBUG:
+  #     $DEBUG = nil
+  #     assert false, 'assert 1'        # nothing happens
+  #     $DEBUG = true
+  #     assert false, 'assert 2'        # AssertionFailure 'assert 2' is raised
+  #     assert 'assert 3', 'assert 4' do
+  #       false
+  #     end                             # AssertionFailure 'assert 3' is raised
+  #
+  # @param [Object] test_expression the expression that will be evaluated; the message if a code block is present
+  # @param [String] message exception message is no code block is present
+  def assert(test_expression, message = 'assertion failure')
+    if $DEBUG
+      if block_given?
+        message = test_expression
+        test_expression = yield
+      end
+      raise AssertionFailure.new(message) unless test_expression
+    end
+  end
+end

data/lib/libis/tools/checksum.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+require 'digest'
+
+module Libis
+  module Tools
+
+    # Common interface for checksum calculations.
+    #
+    # Supported checksum algortihms are MD5, RMD160 (not on JRuby), SHA-1, SHA-2 (256, 384 and 512-bit versions).
+    # All methods are available on the class and on the instance. The instance has to be initialized with a checksum
+    # algorithm and therefore the instance methods do not have to specify the checksum type.
+    #
+    # There are two ways this can be used: using a class instance or using class methods. When a class instance is used,
+    # the desired checksum type has to be supplied when the instance is created. Each call to a checksum method will
+    # calculate the checksum and reset the digest to prevent future calls to be affected by the current result. When a
+    # class method is used besides the file name, the checksum type has to be supplied.
+    #
+    # Examples:
+    #
+    #     require 'libis/tools/checksum'
+    #     checksum = ::Libis::Tools::Checksum.new(:MD5)
+    #     puts "Checksum: #{checksum.hexdigest(file_name)} (MD5, hex)"
+    #
+    #     require 'libis/tools/checksum'
+    #     puts "Checksum: #{::Libis::Tools::Checksum.base64digest(file_name, :SHA384)} (SHA-2, 384 bit, base64)"
+    class Checksum
+      # All supported checksum types
+      CHECKSUM_TYPES = [:MD5, :SHA1, :SHA256, :SHA384, :SHA512]
+
+      # @!visibility private
+      # noinspection RubyResolve
+      unless defined? JRUBY_VERSION
+        checksum_types = CHECKSUM_TYPES
+        checksum_types << :RMD160
+      end
+
+      # Create instance for a given checksum algorithm.
+      #
+      # @param [Symbol] type checksum algorithm; one of {CHECKSUM_TYPES}
+      def initialize(type)
+        @hasher = self.class.get_hasher(type)
+      end
+
+      # Calculate binary digest of a file.
+      #
+      # @param [String] file_path_or_string path of the file to calculate the digest for
+      def digest(file_path_or_string)
+        hashit(file_path_or_string).digest!
+      end
+
+      # Calculate the hexadecimal digest of a file.
+      # @param (see #digest)
+      def hexdigest(file_path_or_string)
+        hashit(file_path_or_string).hexdigest!
+      end
+
+      # Calculate the base64 digest of a file.
+      # @param (see #digest)
+      def base64digest(file_path_or_string)
+        hashit(file_path_or_string).base64digest!
+      end
+
+      # Calculate the binary digest of a file.
+      # @param (see #digest)
+      # @param (see #initialize)
+      def self.digest(file_path_or_string, type)
+        new(type).digest(file_path_or_string)
+      end
+
+      # Calculate the hexadecimal digest of a file.
+      # @param (see #digest)
+      # @param (see #initialize)
+      def self.hexdigest(file_path_or_string, type)
+        new(type).hexdigest(file_path_or_string)
+      end
+
+      # Calculate the base64 digest of a file.
+      # @param (see #digest)
+      # @param (see #initialize)
+      def self.base64digest(file_path_or_string, type)
+        new(type).base64digest(file_path_or_string)
+      end
+
+      # Instatiate a Digest instance for access to low-level functionality
+      # @param (see #initialize)
+      def self.get_hasher(type)
+        raise RuntimeError, "Checksum type '#{type}' not supported." unless CHECKSUM_TYPES.include? type
+        Digest(type).new
+      end
+
+      private
+
+      def hashit(file_path_or_string)
+        if File.exist?(file_path_or_string)
+          @hasher.file(file_path_or_string)
+        else
+          @hasher.reset.update(file_path_or_string)
+        end
+        @hasher
+      end
+
+    end
+
+  end
+end