libis-tools 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9120e1cf4cfed1f9bdfe8529383d4bda5e89e2e
+  data.tar.gz: ab3b461ff790ab4990b63fbc3e63166b8a38471b
+SHA512:
+  metadata.gz: bbdcff4a1240c7c72d0aadea944b045b76c37a71f652515207b4f27c93addce312000efb2f601464f8a55bc5f354c799681111539ab89a19bfbdaee28bc1bc01
+  data.tar.gz: b7619f13ddc7423341ae4a81692e2eec5b52037acf830c828d5db783fd4888ba088b7c95d6e557f6f87583f34e2c1ac0f8cc0162bb334c7990371e5b8fec4681

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,37 @@
+language: ruby
+cache: bundler
+rvm:
+  - 1.9.3
+  - 2.1.0
+  - 2.2.0
+  - ruby-head
+  - jruby-19mode
+jdk:
+  - openjdk7
+  - oraclejdk7
+  - oraclejdk8
+matrix:
+  exclude:
+    - rvm: 1.9.3
+      jdk: oraclejdk7
+    - rvm: 1.9.3
+      jdk: oraclejdk8
+    - rvm: 2.1.0
+      jdk: oraclejdk7
+    - rvm: 2.1.0
+      jdk: oraclejdk8
+    - rvm: 2.2.0
+      jdk: oraclejdk7
+    - rvm: 2.2.0
+      jdk: oraclejdk8
+    - rvm: ruby-head
+      jdk: oraclejdk7
+    - rvm: ruby-head
+      jdk: oraclejdk8
+branches:
+  only:
+      - master
+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 name: 'libis-tools', development_group: :test

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 LIBIS
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,289 @@
+[![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)
+<!--[![Code Climate](https://codeclimate.com/github/Kris-LIBIS/LIBIS_Tools/badges/gpa.svg)](https://codeclimate.com/github/Kris-LIBIS/LIBIS_Tools)
+[![Test Coverage](https://codeclimate.com/github/Kris-LIBIS/LIBIS_Tools/badges/coverage.svg)](https://codeclimate.com/github/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
+
+### assert
+
+The Object#assert method enables the assert functionality found in other languages.
+The method takes an argument that will be interpreted as a boolean expression and an optional message.
+If the boolean expression evaluates to false an AssertionFailure exception will be raised.
+
+Alternatively, if a block is passed to the method, the given block will be evaluated and the result will decide if the
+exception will be raised. In that case the first argument passed to the assert method is used as message and the second
+argument is ignored.
+
+The method will not evaluate the first parameter or block unless the general parameter $DEBUG evaluates to true. That
+means that special care should be taken that the expression does not generate any side effects that the program may rely
+on.
+
+Examples:
+
+```ruby
+    require 'libis/tools/assert'
+    assert(value > 0, 'value should be positive number')
+```
+and using a code block:
+
+```ruby
+    require 'libis/tools/assert'
+    assert 'database is not idle' do
+        db = get_database
+        db.status == :IDLE
+    end
+```
+
+### Checksum
+
+The ::Libis::Tools::Checksum class offers a standardized interface for calculating checksums of file contents in
+different formats. The actual list of supported checksum formats is in ::Libis::Tools::Checksum.CHECKSUM_TYPES. It
+contains MD5, SHA-1 and SHA-2 (in 256-bit, 384-bit and 512-bit variants).
+
+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.
+
+The available methods on both instance and class level are:
+
+* digest: return the checksum as (binary) string.
+* hexdigest: return the checksum as hexadecimal encoded string.
+* base64digest: return the checksum as base64 encoded string.
+
+Examples:
+
+```ruby
+    require 'libis/tools/checksum'
+    checksum = ::Libis::Tools::Checksum.new(:MD5)
+    puts "Checksum: #{checksum.hexdigest(file_name)} (MD5, hex)"
+```
+
+```ruby
+    require 'libis/tools/checksum'
+    puts "Checksum: #{::Libis::Tools::Checksum.base64digest(file_name, :SHA384)} (SHA-2, 384 bit, base64)"
+```
+
+### Command
+
+This module allows to run an external command safely and returns it's output, error messages and status. The run method
+takes any number of arguments that will be used as command-line arguments. The method returns a Hash with:
+
+* :out => an array with lines that were printed on the external program's standard out.
+* :err => an array with lines that were printed on the external program's standard error.
+* :status => exit code returned by the external program.
+
+```ruby
+    require 'libis/tools/command'
+    result = ::Libis::Tools::Command.run('ls', '-l', File.absolute_path(__FILE__))
+    p result # => {out: [...], err: [...], status: 0}
+```
+
+or:
+
+```ruby
+    require 'libis/tools/command'
+    include ::Libis::Tools::Command
+    result = run('ls', '-l', File.absolute_path(__FILE__))
+    p result # => {out: [...], err: [...], status: 0}
+```
+
+Note that the Command class uses Open3#popen3 internally. All arguments supplied to Command#run are passed to the popen3
+call. Unfortunately JRuby has some known issues with popen3. Please use and test carefully in JRuby environments.
+
+### Config
+
+The Config class is a convenience method for easy configuration maintenance and loading. It supports code defaults,
+loading configurations from multiple YAML files containing ERB statements. The Config class follows the Singleton
+pattern and behaves like a Hash/OpenStruct/HashWithIndifferentAccess. It also initializes a default Logger instance.
+
+For each configuration parameter, the value can be accessed via the class or the Singleton instance through a method
+call or via the Hash operator using the parameter name either as a string or a symbol.
+
+Examples:
+
+```ruby
+    require 'libis/tools/config'
+    cfg = ::Libis::Tools::Config
+    cfg['my_value'] = 10
+    p cfg.instance.my_value # => 10
+    cfg.instance.my_text = 'abc'
+    p cfg[:my_text] # => 'abc'
+    p cfg.logger.warn('message') # => W, [2015-03-16T12:51:01.180548 #28935]  WARN -- : message
+```
+
+### Logger
+
+The Logger module adds logging functionality to any class. Just include the ::Libis::Tools::Logger module and the
+methods debug, info, warn, error and fatal will be available to the class instance. Each method takes a message argument
+and optional extra parameters. The methods all call the message method with the logging level as first argument and the
+supplied arguments appended.
+
+The default message method implementation uses the logger of ::Libis::Tools::Config. If extra parameters are supplied,
+the message will be used as a format specification with the extra parameters applied to it. If an 'appname' parameter is
+defined in the Config object, it will be used as program name by the logger, otherwise the class name is taken.
+
+If the class defines a #options method that returns a Hash containing a :quiet key, the value for that key will be
+evaluated and if true debug, info and warning messages will not be printed.
+
+Example:
+
+```ruby
+    require 'libis/tools/logger'
+    class TestLogger
+      include ::Libis::Tools::Logger
+      attr_accessor :options, name
+      def initialize
+        @options = {}
+        @name = nil
+      end
+    end
+    tl = TestLogger.new
+    tl.debug 'message'
+    tl.options[:quiet] = true
+    tl.warn 'message'
+    ::Libis::Tools::Config.appname = 'TestApplication'
+    tl.error 'huge error: [%d] %s', 1000, 'Exit'
+    tl.name = 'TestClass'
+    tl.options[:quiet] = false
+    tl.info 'Running application: %s', ::Libis::Tools::Config.appname
+```
+produces:
+    <pre>
+    D, [...] DEBUG -- TestLogger: message
+    E, [...] ERROR -- TestApplication: huge error: [1000] Exit
+    I, [...]  INFO -- TestClass: Running application TestApplication
+    </pre>
+
+### 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,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/lib/libis-tools.rb

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

data/lib/libis/tools.rb

@@ -0,0 +1,16 @@
+module Libis
+  module Tools
+
+    autoload :Checksum, 'libis/tools/checksum'
+    autoload :Command, 'libis/tools/command'
+    autoload :Config, 'libis/tools/config'
+    autoload :DCRecord, 'libis/tools/dc_record'
+    autoload :Logger, 'libis/tools/logger'
+    autoload :MetsFile, 'libis/tools/mets_file'
+    autoload :Parameter, 'libis/tools/parameter'
+    autoload :XmlDocument, 'libis/tools/xml_document'
+
+  end
+end
+
+require_relative 'tools/extend/struct'

data/lib/libis/tools/assert.rb

@@ -0,0 +1,41 @@
+# 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:
+  #
+  #     $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