libis-tools 1.0.5-java

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

@@ -0,0 +1,16 @@
+
+# Extension class for Array
+class Array
+
+  # Removes all empty entries
+  def cleanup
+    self.delete_if { |v| v.nil? || (v.respond_to?(:empty?) ? v.empty? : false) }
+  end unless method_defined? :cleanup
+
+  # Removes all empty entries recursively in the array and each Hash in it
+  def recursive_cleanup
+    each { |v| v.recursive_cleanup if Array === v || Hash === v }
+    cleanup
+  end unless method_defined? :recursive_cleanup
+
+end

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

@@ -0,0 +1,7 @@
+# Extension for NilClass
+class NilClass
+  # Allows nil.empty?
+  def empty?
+    true
+  end
+end

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

@@ -0,0 +1,147 @@
+require 'backports/rails/hash'
+
+# Extension class for Hash
+class Hash
+
+  # Removes all hash entries for which value.empty? is true
+  def cleanup
+    self.delete_if { |_,v| v.nil? || (v.respond_to?(:empty?) ? v.empty? : false) }
+  end unless method_defined? :cleanup
+
+  # Removes all hash entries for which value.empty? is true. Performed recursively.
+  def recursive_cleanup
+    each { |_, v| v.recursive_cleanup if Array === v || Hash === v }
+    cleanup
+  end unless method_defined? :recursive_cleanup
+
+  # Merges two hashes, but does so recursively.
+  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
+
+  # Merges two hashes in-place, but does so recursively.
+  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!
+
+  # Merges two hashes with priority for the first hash
+  def reverse_merge(other_hash)
+    self.merge(other_hash) {|_,v, _| v}
+  end unless method_defined? :reverse_merge
+
+  # Merges two hashes in-place with priority for the first hash
+  def reverse_merge!(other_hash)
+    self.merge!(other_hash) {|_,v, _| v}
+  end unless method_defined? :reverse_merge!
+
+  # Apply other hash values if current value is blank
+  def apply_defaults(other_hash)
+    self.merge(other_hash) {|_,v, w| v.blank? ? w : v}
+  end unless method_defined? :apply_defaults
+
+  # Apply in-place other hash values if current value is blank
+  def apply_defaults!(other_hash)
+    self.merge!(other_hash) {|_,v, w| v.blank? ? w : v}
+  end unless method_defined? :apply_defaults!
+
+  # Convert all keys to symbols. In-place operation.
+  # @param (see #key_strings_to_symbols)
+  def key_strings_to_symbols!(options = {})
+    self.replace self.key_strings_to_symbols options
+  end unless method_defined? :key_strings_to_symbols!
+
+  # Return new Hash with all keys converted to symbols.
+  # @param [Hash] options valid options are:
+  #   * recursive : perform operation recursively
+  #   * upcase : convert all keys to upper case
+  #   * downcase : convert all keys to lower case
+  #   all options are false by default
+  def key_strings_to_symbols(options = {})
+    options = {resursive: false, upcase: false, downcase: false}.merge options
+
+    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 options[:downcase]
+        k = k.upcase if options[:upcase]
+        k = k.to_sym
+      end
+
+      if options[:recursive]
+        case v
+          when Hash
+            v = v.key_strings_to_symbols options
+          when Array
+            # noinspection RubyResolve
+            v = v.collect { |a| (a.kind_of? Hash) ? a.key_strings_to_symbols(options) :  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
+
+  # Convert all keys to strings. In-place operation.
+  # (@see #key_symbols_to_strings)
+  # @param (see #key_symbols_to_strings)
+  def key_symbols_to_strings!(options = {})
+    self.replace self.key_symbols_to_strings options
+  end unless method_defined? :key_symbols_to_strings!
+
+  # Return new Hash with all keys converted to strings.
+  # (see #key_strings_to_symbols)
+  # @param (see #key_strings_to_symbols)
+  def key_symbols_to_strings(options = {})
+  options = {resursive: false, upcase: false, downcase: false}.merge options
+
+    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 options[:downcase]
+        k = k.upcase if options[:upcase]
+      end
+
+      if options[:recursive]
+        case v
+          when Hash
+            v = v.key_symbols_to_strings(options)
+          when Array
+            # noinspection RubyResolve
+            v = v.collect { |a| (a.kind_of? Hash) ? a.key_symbols_to_strings(options) : 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

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

@@ -0,0 +1,25 @@
+# Extension class
+module Kernel
+
+  # Debugging aid: extract the name of the argument of the last caller
+  def extract_argstring_from(name, call_stack)
+    file, line_number = call_stack.first.match(/^(.+):(\d+)/).captures
+    line = File.readlines(file)[line_number.to_i - 1].strip
+    argstring = line[/#{name}\s*\(?(.+?)\)?\s*($|#|\[|\})/, 1]
+    raise "unable to extract name for #{name} from #{file} line #{line_number}:\n  #{line}" unless argstring
+    argstring
+  end
+
+  # Debugging aid: print "<name> : <value>"
+  #
+  # Example:
+  #     x = 'abc'
+  #     dputs x
+  #     # => x : 'abc'
+  #
+  def dputs(value)
+    name = extract_argstring_from :dputs, caller
+    puts "#{name} : '#{value}'"
+  end
+
+end

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

@@ -0,0 +1,3 @@
+# encoding: utf-8
+require 'ostruct'
+require 'backports/2.0.0/stdlib/ostruct'

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

@@ -0,0 +1,91 @@
+require 'roo'
+require 'roo-xls'
+require 'libis/tools/extend/hash'
+
+module Roo
+  class HeaderRowIncompleteError < Error;
+  end
+  class Base
+
+    # changes:
+    # - added option :partial_match to allow to use headers that only partially match the query
+    # - added option :required_headers to force the result to have at least these columns
+    # - allow option :headers to contain an array with header labels that will be forced when no header row is found
+    # - improved proper range scanning (first_row->last_row and first_column->last_column)
+
+    attr_accessor :partial_match
+
+    def each(options = {})
+      return to_enum(:each, options) unless block_given?
+
+      @partial_match = options.delete(:partial_match) if options.has_key?(:partial_match)
+      required_headers = options.delete(:required_headers) if options.has_key?(:required_headers)
+
+      if options.empty?
+        first_row.upto(last_row) do |line|
+          yield row(line)
+        end
+      else
+        clean_sheet_if_need(options)
+        @headers = search_or_set_header(options)
+        if required_headers
+          raise Roo::HeaderRowIncompleteError unless headers.keys & required_headers == required_headers
+        end
+
+        header_line.upto(last_row) do |line|
+          yield(Hash[headers.map { |k, v| [k, cell(line, v)] }])
+        end
+      end
+    end
+
+    private
+
+    def row_with(query)
+      line_no = first_row
+      each do |row|
+        headers = query.map { |q| row.grep(q)[0] }.compact
+
+        if headers.length == query.length
+          @header_line = line_no
+          return headers
+        elsif line_no > 100
+          raise Roo::HeaderRowNotFoundError
+        elsif headers.length > 0
+          # partial match
+          @header_line = line_no
+          raise Roo::HeaderRowIncompleteError unless partial_match
+          return headers
+        end
+        line_no += 1
+      end
+      raise Roo::HeaderRowNotFoundError
+    end
+
+    def search_or_set_header(options)
+      force_headers = options.delete(:headers)
+      if options[:header_search]
+        row_with(options[:header_search])
+      elsif [:first_row, true].include?(force_headers)
+        @header_line = first_row
+      else
+        return set_headers(options)
+      end
+      return Hash[row(header_line).map { |x| [x, header_index(x)] }]
+    rescue Roo::HeaderRowNotFoundError => e
+      # Not OK unless a list of headers is supplied
+      raise e unless force_headers.is_a?(Array)
+      # Force the headers in the order they are given, but up to the last column
+      @header_line = first_row - 1
+      return Hash[force_headers.zip(first_column..last_column)].cleanup
+    end
+
+    def set_headers(hash)
+      # try to find header row with all values or give an error
+      # then create new hash by indexing strings and keeping integers for header array
+      row_with(hash.values)
+      positions = Hash[row(header_line).map { |x| [x, header_index(x)] }]
+      Hash[positions.map { |k, v| [hash.invert[k] || k, v] }]
+    end
+
+  end
+end

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

@@ -0,0 +1,94 @@
+require 'backports/rails/string'
+
+# Extension class
+class String
+
+  # Check if string is empty
+  def blank?
+    self == ''
+  end unless method_defined? :blank?
+
+  # Create sortable object from string. Supports better natural sorting.
+  def sort_form
+    result = []
+    matcher = /^(\D*)(\d*)(.*)$/
+    self.split('.').each { |s|
+      while !s.empty? and (x = matcher.match s)
+        a = x[1].to_s.strip
+        b = a.gsub(/[ _]/, '')
+        result << [b.downcase, b, a]
+        result << x[2].to_i
+        s = x[3]
+      end
+    }
+    result
+  end unless method_defined? :sort_form
+
+  # Quote string for command-line use.
+  def quote
+    '\"' + self.gsub(/"/) { |s| '\\' + s[0] } + '\"'
+  end unless method_defined? :quote
+
+  # Escape string for use in Regular Expressions
+  def escape_for_regexp
+    self.gsub(/[\.\+\*\(\)\{\}\|\/\\\^\$"']/) { |s| '\\' + s[0].to_s }
+  end
+
+  # Escape double quotes for usage in code strings.
+  def escape_for_string
+    self.gsub(/"/) { |s| '\\' + s[0].to_s }
+  end
+
+  # Escape double quotes for usage in passing through scripts
+  def escape_for_cmd
+    self.gsub(/"/) { |s| '\\\\\\' + s[0].to_s }
+  end
+
+  # Escape single quotes for usage in SQL statements
+  def escape_for_sql
+    self.gsub(/'/) { |s| ($` == '' || $' == '' ? '' : '\'') + s[0].to_s }
+  end
+
+  def dot_net_clean
+    self.gsub /^(\d+|error|float|string);\\?#/, ''
+  end
+
+  # Convert whitespace into underscores
+  def remove_whitespace
+    self.gsub(/\s/, '_')
+  end
+
+  # Escape all not-printabe characters in hex format
+  def encode_visual(regex = nil)
+    regex ||= /\W/
+    self.gsub(regex) { |c| '_x' + '%04x' % c.unpack('U')[0] + '_'}
+  end unless method_defined? :encode_visual
+
+  # Convert all not-printable characters encoded in hex format back to original
+  def decode_visual
+    self.gsub(/_x([0-9a-f]{4})_/i) { [$1.to_i(16)].pack('U') }
+  end unless method_defined? :decode_visual
+
+  # Align a multi-line string to the left by removing as much spaces from the left as possible.
+  def align_left
+    string = dup
+    relevant_lines = string.split(/\r\n|\r|\n/).select { |line| line.size > 0 }
+    indentation_levels = relevant_lines.map do |line|
+      match = line.match(/^( +)[^ ]+/)
+      match ? match[1].size : 0
+    end
+    indentation_level = indentation_levels.min
+    string.gsub! /^#{' ' * indentation_level}/, '' if indentation_level > 0
+    string
+  end unless method_defined? :align_left
+
+end
+
+# Extension class
+class NilClass
+
+  # Allow nil.blank? so that blank? can be applied without errors.
+  def blank?
+    true
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'json'
+require 'backports/rails/hash'
+require 'backports/2.0.0/struct'
+
+class Struct
+  # def to_hash
+  #   members.inject({}) {|h,m| h[m] = send(m); h}
+  # end unless method_defined? :to_hash
+
+  def set(h = {})
+    h.symbolize_keys!
+    members.each {|m| send("#{m}=", h[m]) if h.key?(m)}
+    self
+  end unless method_defined? :set
+
+  def self.from_hash(h)
+    h.symbolize_keys!
+    members.inject(new) {|o,m| o[m] = h[m] if h.key?(m); o}
+  end unless respond_to? :from_hash
+
+  def to_json
+    to_hash.to_json
+  end unless method_defined? :to_json
+
+  def self.from_json(j)
+    from_hash(JSON.parse(j))
+  end unless respond_to? :from_json
+end

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

@@ -0,0 +1,8 @@
+# Symbol monkey patch to allow map(&:method) to take arguments. Allows: [2,3].map(&:+.(10)) # => [12,13]
+# See: https://stackoverflow.com/questions/23695653/can-you-supply-arguments-to-the-mapmethod-syntax-in-ruby
+# for more information,
+class Symbol
+  def call(*args, &block)
+    ->(caller, *rest) { caller.public_send(self, *rest, *args, &block) }
+  end
+end

data/lib/libis/tools/logger.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+require 'backports'
+require 'libis/tools/config'
+require 'libis/tools/extend/string'
+
+module Libis
+  module Tools
+
+    # This 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.
+    #
+    # It is possible to overwrite the {#logger} method with your own implementation to use
+    # a different logger for your class.
+    #
+    # The methods all call the {#message} method with the logging level as first argument
+    # and the supplied arguments appended.
+    #
+    # Example:
+    #
+    #     require 'libis/tools/logger'
+    #     class TestLogger
+    #       include ::Libis::Tools::Logger
+    #       attr_accessor :options, name
+    #     end
+    #     tl = TestLogger.new
+    #     tl.debug 'message'
+    #     tl.warn 'message'
+    #     tl.error 'huge error: [%d] %s', 1000, 'Exit'
+    #     tl.info 'Running application: %s', t.class.name
+    #
+    # produces:
+    #     D, [...] DEBUG : message
+    #     W, [...]  WARN : message
+    #     E, [...] ERROR : huge error: [1000] Exit
+    #     I, [...]  INFO : Running application TestLogger
+    #
+    module Logger
+
+      # Get the logger instance
+      #
+      # Default implementation is to get the root logger from the Config, but can be overwritten for sub-loggers.
+      # @!method(logger)
+      def logger
+        ::Libis::Tools::Config.logger
+      end
+
+      def set_application(name = nil)
+        name ||= self.class.name
+        ::Logging.mdc['Application'] = name.blank? ? '' : " -- #{name}"
+      end
+
+      def set_subject(name = nil)
+        ::Logging.mdc['Subject'] = name.blank? ? '' : " - #{name}"
+      end
+
+      # Send a debug message to the logger.
+      #
+      # If the optional extra parameters are supplied, the first parameter will be interpreted as a format
+      # specification. It's up to the caller to make sure the format specification complies with the number and
+      # types of the extra arguments. If the format substitution fails, the message will be printed as:
+      # '<msg> - [<args>]'.
+      #
+      # @param [String] msg the message.
+      # @param [Array] args optional extra arguments.
+      # @!method(debug(msg, *args))
+      def debug(msg, *args)
+        self.message :DEBUG, msg, *args
+      end
+
+      # Send an info message to the logger.
+      #
+      # (see #debug)
+      # @param (see #debug)
+      # @!method(info(msg, *args))
+      def info(msg, *args)
+        self.message :INFO, msg, *args
+      end
+
+      # Send a warning message to the logger.
+      #
+      # (see #debug)
+      # @param (see #debug)
+      # @!method(warn(msg, *args))
+      def warn(msg, *args)
+        self.message :WARN, msg, *args
+      end
+
+      # Send an error message to the logger.
+      #
+      # (see #debug)
+      # @param (see #debug)
+      # @!method(error(msg, *args))
+      def error(msg, *args)
+        self.message :ERROR, msg, *args
+      end
+
+      # Send a fatal message to the logger.
+      #
+      # (see #debug)
+      # @param (see #debug)
+      # @!method(fatal_error(msg, *args))
+      def fatal_error(msg, *args)
+        self.message :FATAL, msg, *args
+      end
+
+      # The method that performs the code logging action.
+      #
+      # If extra arguments are supplied, the message string is expected to be a format specification string and the
+      # extra arguments will be applied to it.
+      #
+      # This default message method implementation uses the logger of ::Libis::Tools::Config. 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.
+      #
+      # @param [{::Logger::Severity}] severity
+      # @param [String] msg message string
+      # @param [Object] args optional list of extra arguments
+      # @!method(message(severity, msg, *args))
+      def message(severity, msg, *args)
+        message_text = (msg % args rescue "#{msg}#{args.empty? ? '' : " - #{args}"}")
+        self.logger.add(::Logging.level_num(severity), message_text)
+      end
+
+    end
+
+  end
+end