hash_base 0.1.6

data/lib/hash_base/array/to_html.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+#
+# utilities for ruby hashes and ruby arrays
+#
+# Copyright © 2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+class Array
+
+  ########################################################################################
+  #
+  # to_html: creates a html table from a rectangular array
+  #
+  # options: headings: true/false, footer:  true/false
+  #
+  ########################################################################################
+  def to_html(options={}, &block)
+  
+    options[:table] = options[:table].to_h.merge({:class => options[:table_class]}.compact) # support legacy
+    
+    t          = dup
+          body = t
+    head, body = [t.shift, t] if options[:headings]
+    foot, body = [t.pop  , t] if options[:footer]
+    
+    html_tag(:table, options[:table].to_h.compact) do
+      [head].compact.table_row_group(options.merge(:row_group => {:type => :thead}, :cell => {:type => :th}), &block) +
+        body.compact.table_row_group(options.merge(:row_group => {:type => :tbody}, :cell => {:type => :td}), &block) +
+      [foot].compact.table_row_group(options.merge(:row_group => {:type => :tfoot}, :cell => {:type => :td}), &block) 
+    end
+  end #def
+  
+  
+  def table_row_group(options={}, &block)
+    rows =  collect.with_index do |row, row_index|
+      row.table_row(row_index, options, &block)
+    end.join("")
+    rows.present? ? html_tag(options.dig(:row_group, :type) || :tbody, rows) : ""
+  end #def
+  
+  def table_row(row_index, options={}, &block)
+    html_tag(:tr, options[:row].to_h.compact) do
+      row = collect.with_index do |value, column_index| 
+        html_tag(options.dig(:cell, :type) || :td, options[:cell].to_h.except(:type).compact) do
+          cell_value = if block_given?
+            yield value, column_index, row_index
+          else
+            style_value(value, options)
+          end
+        end #html_tag #cell_type
+      end.join("") #collect columns
+      row
+    end #html_tag #tr
+  end #def
+  
+  ########################################################################################
+  private
+  ########################################################################################
+  def style_value(value, options={}, &block)
+    case value.class
+    when Integer
+      value.to_s
+    when Numeric
+      p = options[:precision] || 2
+      sprintf("%.#{p}f",value)
+    else
+      options[:html_safe] ? value.to_s : CGI::escapeHTML(value.to_s)
+    end 
+  end #def
+  
+  def html_tag(type, *content, &block)
+    if block_given?
+      opts = content.first.to_h.map{|k,v| " #{k}='#{v}'"}.join
+      "<#{type}#{opts}>#{yield block}</#{type}>"
+    else
+      opts = content[1].to_h.map{|k,v| " #{k}='#{v}'"}.join
+      "<#{type}#{opts}>#{content.first}</#{type}>"
+    end
+  end #def
+  
+end

data/lib/hash_base/array/to_list.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+#
+# utilities for ruby hashes and ruby arrays
+#
+# Copyright © 2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+class Array
+
+  ########################################################################################
+  #
+  # converts array of hashes to one hash with elements in array
+  #
+  ########################################################################################
+  class ArrayRowIsNotAHash  < StandardError; end
+  
+  def to_list
+    # test, if each element is a hash
+    each do |hash|
+      raise ArrayRowIsNotAHash unless hash.is_a?(Hash)
+    end
+    # extract all keys from all hashes
+    keys = map do |hash|
+      hash.keys
+    end.flatten.uniq
+    # now extract value for each key in each hash
+    map do |hash|
+      keys.map do |key|
+        hash[key]
+      end
+    end.unshift(keys)
+  end #def
+  
+end

data/lib/hash_base/array/to_text.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+#
+# utilities for ruby hashes and ruby arrays
+#
+# Copyright © 2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+class Array
+
+  ########################################################################################
+  #
+  # creates a table from a rectangular array, balanced with indent
+  #
+  #  indent:              (Integer) number of spaces for padding each table element
+  #  precision            (Integer) number of precision digits to print for floats
+  #  padding              (String)  string between adjacing colums
+  ########################################################################################
+  def to_text(indent: 15, precision: 2, padding: " | " )
+    map do |line| 
+      ln = line.is_a?(Array) ? line : [line]
+      ln.map do |e| 
+        case e 
+        when Integer
+          e.to_s.rjust(indent)
+        when Complex, Rational
+          e.to_s.rjust(indent)
+        when Numeric
+          sprintf("%.#{precision}f",e).rjust(indent)
+        else
+          e.to_s.ljust(indent)
+        end
+      end.join(padding)
+    end.join("\n")
+  end #def 
+  
+end

data/lib/hash_base/hash/apply.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+#
+# utilities for ruby hashes
+#
+# Copyright © 2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+class Hash
+
+  ########################################################################################
+  #
+  # apply(&block): applies block to deepest element, which is not a Hash
+  #
+  # -> hash
+  #    new hash ->
+  #
+  ########################################################################################
+  def apply( &block )
+    return to_enum(:each) unless block_given?
+    hash = Hash.new
+    each do |key, value|
+      if  value.is_a?(Hash)
+        hash[key] = value.apply( &block ) 
+      else
+        hash[key] = yield value
+      end
+    end
+    hash
+  end #def
+  
+  ########################################################################################
+  #
+  # apply!(&block): applies block to deepest element, which is not a Hash
+  #
+  # -> hash
+  #    same hash ->
+  #
+  ########################################################################################
+  def apply!( &block )
+    return to_enum(:each) unless block_given?
+    each do |key, value|
+      if value.is_a?(Hash)
+        self[key] = value.apply( &block ) 
+      else
+        self[key] = yield value
+      end
+    end
+    self
+  end #def
+  
+end

data/lib/hash_base/hash/deep_values.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+#
+# utilities for ruby hashes
+#
+# Copyright © 2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+class Hash
+
+  ########################################################################################
+  #
+  # deep_values: gets an array of values of a nested hash as a flat array
+  #
+  # -> hash
+  #    array ->
+  #
+  ########################################################################################
+  def deep_values
+    arr = Array.new
+    each do |key, value|
+      if  value.is_a?(Hash)
+        arr += value.deep_values
+      else
+        arr << value
+      end
+    end #each
+    arr
+  end #def
+  
+  
+  ########################################################################################
+  #
+  # max_depth: gets max depth of a hash
+  #
+  # -> hash
+  #    int ->
+  #
+  ########################################################################################
+  def max_depth(depth: 1)
+    max_depth = depth
+    each do |k,v|
+      if v.is_a?(Hash)
+        max_depth = [max_depth, v.max_depth( depth: depth + 1 )].max
+      end
+    end
+    max_depth
+  end #def
+  
+  ########################################################################################
+  #
+  # deep_diff: compares two hashes - counter part to Array.deep_diff
+  #            source: stackoverflow
+  #
+  ########################################################################################
+  def deep_diff(other, &block)
+    (self.keys + other.keys).uniq.inject({}) do |memo, key|
+      left = self[key]
+      right = other[key] 
+      
+      if block_given?
+        next memo if yield left, right 
+      else
+        next memo if left == right 
+      end
+      if left.respond_to?(:deep_diff) && right.respond_to?(:deep_diff)
+        memo[key] = left.deep_diff(right)
+      else
+        memo[key] = [left, right]
+      end
+      
+      memo
+    end
+  end  
+  
+end

data/lib/hash_base/hash/grouping.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+#
+# utilities for ruby hashes and ruby arrays
+#
+# Copyright © 2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+class Hash
+
+  ########################################################################################
+  #
+  # group_by_positions: counter part to Array.group_by_positions
+  # 
+  # will only be invoked by Array.group_by_positions
+  #
+  ########################################################################################
+  def group_by_positions( *positions )
+    ohash = ActiveSupport::OrderedHash.new
+    each do |key, val|
+      case val
+      when Hash, Array
+        ohash[key] = val.group_by_positions( *positions )
+      else
+        ohash[key] = val
+      end
+    end #each
+    ohash
+  end #def
+  
+  ########################################################################################
+  #
+  # expand: reverse of group_by_positions
+  # 
+  # -> nested_hash 
+  #          -> array
+  #
+  ########################################################################################
+  def expand(path_to_here=[])
+    arry     = []
+    each do |k, v|
+      if v.is_a?(Hash)
+        arry += v.expand(path_to_here + [k])
+      elsif v.is_a?(Array)
+        v.each do |el|
+          arry << (path_to_here + [k] +  el  ) if     el.is_a?(Array)
+          arry << (path_to_here + [k] + [el] ) unless el.is_a?(Array)
+        end
+      else
+        arry << (path_to_here + [k] + [v])
+      end
+    end
+    arry
+  end #def
+  
+end

data/lib/hash_base/hash/to_table.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+#
+# utilities for ruby hashes and ruby arrays
+#
+# Copyright © 2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+class Hash
+
+  ########################################################################################
+  #
+  # to_table: creates a rectangular table from a nested hash
+  #
+  # -> hash
+  #    array ->
+  #
+  #  parameters
+  #
+  #  level:               (Integer) only used internally for recursive calls (do not use)
+  #  indent:              (Integer) number of spaces for padding each table element
+  #  precision            (Integer) number of precision digits for floats
+  #  dosort;              (Boolean) should each level of keys be sorted ?
+  #  content:             (String) "style" => creates a table of cell styles, else table
+  #                                 of data
+  #  format:              (String) "text" - text output, balanced with indent parameter 
+  #                                "html" - html output
+  #  total:               (Proc)   "-> x {x.flatten.inject(:+)}" proc to create totals of 
+  #                                 arrays of deepest values
+  #  total_caption        (String) caption for total line 
+  #  grand_total          (Proc)   "-> x {x.depp_values.flatten.inject(:+)}" proc to 
+  #                                create totals of arrays of deepest values
+  #  grant_total_caption  (string) caption for grand total line
+  #  
+  ########################################################################################
+  def to_table( level: 0, indent: 15, precision: 2, dosort: true, content: "data", format: nil, divisor: nil, total: nil, total_caption: "", grand_total: nil, grand_total_caption: "" )
+    
+    arry = []
+    i    = 0
+    
+    h = dosort ? sort : self
+    
+    h.each do |k, v|
+    
+      first_line = Array.new( i > 0 ? level : 0) {""} + [k]                                    unless content == "style"
+      first_line = Array.new( i > 0 ? level : 0) {|l| "empty level_#{l}"} + ["key level_#{level}"] if content == "style"
+      
+      if v.is_a?(Hash)
+        lines = v.to_table(level: level + 1, content: content, indent: indent, dosort: dosort, divisor: divisor, total: total, total_caption: total_caption, grand_total: grand_total, grand_total_caption: grand_total_caption)
+        first_line += lines[0] # complement current line with last key
+        arry << first_line
+        arry += lines.drop(1) if lines.drop(1).present?
+      elsif v.is_a?(Array) #must be array
+        lines = []
+        v.each_with_index do |av, i|
+          elem = (av.is_a?(Array) ? av : [av])
+          lines << (Array.new( i > 0 ? level + 1 : 0) {""} + elem )                                                            unless content == "style"
+          lines << (Array.new( i > 0 ? level + 1 : 0) {|l| "empty level_#{l}"} + Array.new(elem.length){"value level_#{level}"} )  if content == "style"
+        end
+        first_line += lines[0] # complement current line
+        arry << first_line
+        arry += lines.drop(1) if lines.drop(1).present?
+        
+        max_len = arry.map{|r| r.length}.max
+        
+        unless content == "style"
+          arry << (Array.new( max_len + 1) {divisor.to_s * indent} )                        if total && divisor
+          arry << (["#{total_caption}"] + Array.new( max_len - 1) {""} + [total.yield(v)] ) if total
+          arry << (Array.new( max_len + 1) {""} )                                           if total && divisor
+        else
+          arry << (Array.new( max_len + 1) {|l| "divisor level_#{l}"} )                                                        if total && divisor
+          arry << (["total_caption level_0"] + Array.new( max_len - 1) {|l| "empty level_#{l+1}"} + ["total level_#{level}"] ) if total
+          arry << (Array.new( max_len + 1) {|l| "empty level_#{l}"} )                                                          if total && divisor
+        end
+      end
+      i+=1
+    end #each
+    
+    if level == 0
+    
+      max_len = arry.map{|r| r.length}.max
+      
+      unless content == "style"
+        arry << (Array.new( max_len + 1 ) {divisor.to_s * indent} )                                             if grand_total && divisor
+        arry << (["#{grand_total_caption}"]      + Array.new( max_len - 1 ) {""} + [grand_total.yield(self)] )  if grand_total
+      else
+        arry << (Array.new( max_len + 1) {"grand_total divisor"} )                                                                   if grand_total && divisor
+        arry << (["grand_total_caption level_0"] + Array.new( max_len - 1) {|l| "empty grand_total level_#{l+1}"} + ["grand_total"]) if grand_total
+      end
+      
+      
+      max_len = arry.map{|r| r.length}.max
+      
+      arry.map!{|l| l += Array.new(max_len - l.length) {""} }          unless content == "style"
+      arry.map!{|l| l += Array.new(max_len - l.length) {"empty padding"} } if content == "style"
+      
+      if format == "text"
+        arry.to_text(indent: indent, precision: precision)
+      elsif format == "html"
+        arry.to_html( styles: self.to_table(content: "style", total: true, grand_total: true))
+      else
+        arry
+      end
+    else
+      arry
+    end
+    
+  end #def
+  
+end

data/lib/hash_base/hash/zip_out.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+#
+# utilities for ruby hashes
+#
+# Copyright © 2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+class Hash
+
+  ########################################################################################
+  #
+  # zip_out: puts elements into one zip file with keys as filenames
+  #
+  # -> hash
+  #    zip ->
+  #
+  # depends on gem 'zip'
+  #
+  ########################################################################################
+  def zip_out(&block)
+  
+    return nil unless defined?(Zip)
+    
+    zip_stream = Zip::OutputStream.write_buffer do |zip|
+    
+     each do |key, obj|
+        zip.put_next_entry(key)
+        if block_given?
+          zip.write(yield obj)
+        else
+           zip.write(obj)
+        end
+      end
+    end
+    
+    # important - rewind the steam
+    zip_stream.rewind
+    
+    # read out zip contents
+    zip_stream.read
+    
+  end #def
+  
+end

data/lib/hash_base/version.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+#
+# deep_try works like try, but with an arbitrary long list of methods
+#
+# Copyright © 2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+module HashBase
+  VERSION = "0.1.6"
+end

data/lib/hash_base.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+#
+# utilities for ruby hashes and ruby arrays
+#
+# Copyright © 2021 Stephan Wenzel <stephan.wenzel@drwpatent.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+require "hash_base/hash/grouping"
+require "hash_base/hash/apply"
+require "hash_base/hash/deep_values"
+require "hash_base/hash/to_table"
+require "hash_base/hash/zip_out"
+
+require "hash_base/array/grouping"
+require "hash_base/array/to_html"
+require "hash_base/array/to_list"
+require "hash_base/array/to_text"