libis-tools 0.9.1

data/lib/libis/tools/checksum.rb

@@ -0,0 +1,84 @@
+# 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.
+    #
+    class Checksum
+      if defined? JRUBY_VERSION
+        CHECKSUM_TYPES = [:MD5, :SHA1, :SHA256, :SHA384, :SHA512]
+      else
+        CHECKSUM_TYPES = [:MD5, :RMD160, :SHA1, :SHA256, :SHA384, :SHA512]
+      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)
+        @hasher.file(file_path_or_string).digest!
+      end
+
+      # Calculate the hexadecimal digest of a file.
+      # @param (see #digest)
+      def hexdigest(file_path_or_string)
+        @hasher.file(file_path_or_string).hexdigest!
+      end
+
+      # Calculate the base64 digest of a file.
+      # @param (see #digest)
+      def base64digest(file_path_or_string)
+        @hasher.file(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)
+        @hasher.file(file_path_or_string)
+      end
+
+    end
+
+  end
+end

data/lib/libis/tools/command.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+require 'open3'
+
+module Libis
+  module Tools
+
+    module Command
+
+      # Run an external program and return status, stdout and stderr.
+      #
+      #
+      # @param [String] cmd program name
+      # @param [Array<String>] opts optional list of command line arguments
+      # @return [Hash] a Hash with:
+      #         * +:status+ : the exit status of the command
+      #         * +:out+ : the stdout output of the command
+      #         * +:err+ : the stderr output of the command
+      def self.run(cmd, *opts)
+        result = {}
+        begin
+          Open3.popen3(cmd, *opts) do |_, output, error, thread|
+            output = output.read
+            error = error.read
+            result[:out] = output.split("\n").map(&:chomp)
+            result[:err] = error.split("\n").map(&:chomp)
+            result[:status] = thread.value.exitstatus rescue nil
+          end
+
+        rescue Exception
+          # ignored
+
+        end
+
+        result
+
+      end
+    end
+
+  end
+end

data/lib/libis/tools/config.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+require 'singleton'
+require 'set'
+require 'yaml'
+require 'erb'
+require 'logger'
+require 'backports'
+
+require 'libis/tools/extend/hash'
+
+module Libis
+  module Tools
+
+    # 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.
+    # The class also stores a system-wide {::Logger} instance that will be used by {::Libis::Tools::Logger}.
+    #
+    # The parameters can be accessed by getter/setter method or using the Hash syntax:
+    #
+    #         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
+    #
+    class Config
+      include Singleton
+
+      class << self
+
+        private
+
+        # For each configuration parameter, the value can be accessed via the class or the Singleton instance.
+        def method_missing(name, *args, &block)
+          instance.send(name, *args, &block)
+        end
+
+      end
+
+      # Load configuration parameters from a YAML file or Hash.
+      #
+      # The YAML file can contain ERB syntax values that will be evaluated at loading time. Multiple files can be
+      # loaded. Instead of a YAML file, a Hash can be passed. The file paths and Hashes are memorised and loaded again
+      # by the {#reload} methods.
+      # @param [String,Hash] file_or_hash
+      def <<(file_or_hash)
+        return if file_or_hash.nil?
+        hash = case file_or_hash
+                 when Hash
+                   @sources << file_or_hash
+                   file_or_hash
+                 when String
+                   return unless File.exist?(file_or_hash)
+                   @sources << File.absolute_path(file_or_hash)
+                   data = ERB.new(open(file_or_hash).read).result
+                   # noinspection RubyResolve
+                   YAML.load(data).to_hash rescue {}
+                 else
+                   {}
+               end
+        @data.merge! hash.key_symbols_to_strings recursive: true
+        self
+      end
+
+      # Load all files and Hashes again. Will not reset the configuration parameters. Parameters set directly on the
+      # configuration are kept intact unless they also exist in the files or hashes in which case they will be overwritten.
+      def reload
+        sources = @sources.dup
+        @sources.clear
+        sources.each { |f| self << f }
+        self
+      end
+
+      # Load all files and Hashes again. All configuration parameters are first deleted which means that any parameters
+      # added directly (not via file or hash) will no longer be available. Parameters set explicitly that also exist in
+      # the files or hashes will be reset to the values in those files and hashes.
+      def reload!
+        @data.clear
+        reload
+      end
+
+      # Get the value of a parameter.
+      # @param [String, Symbol] name parameter name
+      # @return [Object] parameter value; nil if the parameter does not exist
+      def [](name)
+        @data.fetch(name.to_s) rescue nil
+      end
+
+      # Set the value of a parameter.
+      # If the parameter does not yet exist, it will be created.
+      # @param (see #[])
+      # @param [Object] value the new value for the parameter
+      # @return [Object] parameter value
+      def []=(name, value)
+        @data.store(name.to_s, value)
+      end
+
+      # Return the ::Logger instance.
+      def logger
+        @logger
+      end
+
+      # Set the ::Logger instance.
+      # @param [::Logger] my_logger new logger instance
+      def logger=(my_logger)
+        @logger = my_logger
+      end
+
+      # Set the ::Logger instance's formatter.
+      # If the supplied formatter is missing or nil, a default formatter will be applied. The default formatter prints
+      # log lines like this:
+      #
+      #     <first char of severity>, [<timestamp>#<process-id>] <severity> -- <program_name> : <message>
+      #
+      # @param [Proc] formatter the formatter procedure or nil for default formatter
+      def set_log_formatter(formatter = nil)
+        logger.formatter = formatter || proc do |severity, time, progname, msg|
+          "%s, [%s#%d] %5s -- %s: %s\n" % [severity[0..0],
+                                           (time.strftime('%Y-%m-%dT%H:%M:%S.') << '%06d ' % time.usec),
+                                           $$, severity, progname, msg]
+        end
+      end
+
+      private
+
+      def method_missing(name, *args)
+        key = name.to_s
+        if name.to_s =~ /^(.*)(=)$/
+          key = $1
+        end
+        if @data.has_key?(key)
+          if key =~/^\w+$/ # not all key names are safe to use as method names
+            self.instance_eval <<-END
+              def #{key}
+                self['#{key}']
+              end
+              def #{name}=(value)
+                self['#{name}'] = value
+              end
+            END
+          end
+        end
+        ($2.nil? || $2.empty?) ? (@data.fetch(key) rescue nil) : @data.store(key, args.first)
+      end
+
+      def initialize
+        @data = Hash.new
+        @sources = Array.new
+        @logger = ::Logger.new(STDOUT)
+        set_log_formatter
+      end
+
+    end
+  end
+end
+

data/lib/libis/tools/dc_record.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require_relative 'xml_document'
+
+module Libis
+  module Tools
+
+    class DCRecord < XmlDocument
+
+      # noinspection RubyResolve
+      def initialize(doc = nil)
+        super('utf-8')
+        case doc
+          when NilClass
+            build do |xml|
+              xml[:dc].record('xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+                         'xmlns:dc' => 'http://purl.org/dc/elements/1.1/',
+                         'xmlns:dcterms' => 'http://purl.org/dc/terms/') {
+                yield xml if block_given?
+              }
+            end
+          when ::Libis::Tools::XmlDocument
+            @document = doc.document.dup
+          when String
+            if File.exist?(doc)
+              # noinspection RubyResolve
+              load(doc)
+            else
+              parse(doc)
+            end
+          when Hash
+            self.from_hash(doc)
+          when IO
+            self.parse(doc.read)
+          else
+            raise ArgumentError, "Invalid argument: #{doc.inspect}"
+        end
+      end
+
+      def add(tag, value = nil, attributes = {})
+        add_node(tag, value, root, attributes)
+      end
+
+    end
+
+  end
+end

data/lib/libis/tools/extend/empty.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+class NilClass
+  def empty?
+    true
+  end
+end

data/lib/libis/tools/extend/hash.rb

@@ -0,0 +1,107 @@
+require 'backports/rails/hash'
+
+class Hash
+
+  def cleanup
+    self.delete_if { |_,v| v.nil? || (v.respond_to?(:empty?) ? v.empty? : false) }
+  end unless method_defined? :cleanup
+
+  def recursive_cleanup
+    delete_proc = Proc.new do |_, v|
+      v.delete_if(&delete_proc) if v.kind_of?(Hash)
+      v.nil? || (v.respond_to?(:empty?) ? v.empty? : false)
+    end
+    self.delete_if &delete_proc
+  end unless method_defined? :recursive_cleanup
+
+  def recursive_merge(other_hash)
+    self.merge(other_hash) do |_, old_val, new_val|
+      if old_val.is_a? Hash
+        old_val.recursive_merge new_val
+      else
+        new_val
+      end
+    end
+  end unless method_defined? :recursive_merge
+
+  def recursive_merge!(other_hash)
+    self.merge!(other_hash) do |_, old_val, new_val|
+      if old_val.is_a? Hash
+        old_val.recursive_merge new_val
+      else
+        new_val
+      end
+    end
+  end unless method_defined? :recursive_merge!
+
+  def key_strings_to_symbols(opts = {})
+    opts = {resursive: false, upcase: false, downcase: false}.merge opts
+
+    r = Hash.new
+    self.each_pair do |k,v|
+
+      k = k.to_s if k.kind_of? Symbol
+      if k.kind_of? String
+        k = k.downcase if opts[:downcase]
+        k = k.upcase if opts[:upcase]
+        k = k.to_sym
+      end
+
+      if opts[:recursive]
+        case v
+          when Hash
+            v = v.key_strings_to_symbols opts
+          when Array
+            # noinspection RubyResolve
+            v = v.collect { |a| (a.kind_of? Hash) ? a.key_strings_to_symbols(opts) :  Marshal.load(Marshal.dump(a)) }
+          else
+            # noinspection RubyResolve
+            v = Marshal.load(Marshal.dump(v))
+        end
+      end
+
+      r[k] = v
+
+    end
+
+    r
+  end unless method_defined? :key_strings_to_symbols
+
+  def key_symbols_to_strings!(opts = {})
+    self.replace self.key_symbols_to_strings opts
+  end unless method_defined? :key_symbols_to_strings!
+
+  def key_symbols_to_strings(opts = {})
+    opts = {resursive: false, upcase: false, downcase: false}.merge opts
+
+    r = Hash.new
+    self.each_pair do |k,v|
+
+      k = k.to_sym if k.kind_of? String
+      if k.kind_of? Symbol
+        k = k.to_s
+        k = k.downcase if opts[:downcase]
+        k = k.upcase if opts[:upcase]
+      end
+
+      if opts[:recursive]
+        case v
+          when Hash
+            v = v.key_symbols_to_strings(opts)
+          when Array
+            # noinspection RubyResolve
+            v = v.collect { |a| (a.kind_of? Hash) ? a.key_symbols_to_strings(opts) : Marshal.load(Marshal.dump(a)) }
+          else
+            # noinspection RubyResolve
+            v = Marshal.load(Marshal.dump(v))
+        end
+      end
+
+      r[k] = v
+
+    end
+
+    r
+  end unless method_defined? :key_symbols_to_strings
+
+end